@northguild/gmt 1.15.0 → 1.17.0

package/dist/internal/temporalCompat/repros.js

@@ -0,0 +1,556 @@
+import { Temporal } from "@js-temporal/polyfill";
+const MAX_ISO = "+275760-09-13";
+const MIN_ISO = "-271821-04-19";
+/** `year|monthCode|day` of an ISO date read in `calendar`. */
+function readFields(iso, calendar) {
+    const date = Temporal.PlainDate.from(iso).withCalendar(calendar);
+    return `${date.year}|${date.monthCode}|${date.day}`;
+}
+function fieldsToIso(calendar, year, month, day) {
+    return Temporal.PlainDate.from({ calendar, year, month, day }, { overflow: "reject" })
+        .withCalendar("iso8601")
+        .toString();
+}
+/**
+ * test262 `intl402/Temporal/PlainDate/from/extreme-dates.js`, as
+ * `[calendar, minYear, minMonth, minDay, maxYear, maxMonth, maxDay]` (ordinal months).
+ */
+const extremeDateRows = [
+    ["buddhist", -271278, 4, 19, 276303, 9, 13],
+    ["hebrew", -268058, 11, 4, 279517, 10, 11],
+    ["indian", -271899, 1, 29, 275682, 6, 22],
+    ["islamic-civil", -280804, 3, 21, 283583, 5, 23],
+    ["islamic-tbla", -280804, 3, 22, 283583, 5, 24],
+    ["islamic-umalqura", -280804, 3, 21, 283583, 5, 23],
+    ["persian", -272442, 1, 9, 275139, 7, 12],
+    ["ethioaa", -266323, 3, 23, 281247, 5, 22],
+];
+/** D1: fields → ISO probes outside the legacy `Date` range near both limits and throws. */
+const d1Repros = extremeDateRows.flatMap(([calendar, minY, minM, minD, maxY, maxM, maxD]) => [
+    {
+        defect: "D1",
+        calendar,
+        name: "fieldsMax",
+        expected: MAX_ISO,
+        run: () => fieldsToIso(calendar, maxY, maxM, maxD),
+    },
+    {
+        defect: "D1",
+        calendar,
+        name: "fieldsMin",
+        expected: MIN_ISO,
+        run: () => fieldsToIso(calendar, minY, minM, minD),
+    },
+]);
+/**
+ * D10 (tc39/proposal-temporal#3329): proposal-temporal #3292 gave `calendarToIsoDate` a fixed 8-day
+ * search step, which skips a 5- or 6-day month 13 in far years and trips an assertion. Polyfill
+ * 0.5.1 predates #3292 and passes; these rows catch a js-temporal release that ports #3292 without
+ * the #3329 fix. GMT computes coptic and ethiopic in ethioaa (`calendarSystemIds.ts`), so ethioaa
+ * is the only id probed. Chromium 153 native Temporal: ethioaa 18196 (coptic 12420 + 5776).
+ */
+const d10Repros = [
+    {
+        defect: "D10",
+        calendar: "ethioaa",
+        name: "fieldsFarMonth13",
+        expected: "+012704-11-26",
+        run: () => fieldsToIso("ethioaa", 18196, 13, 1),
+    },
+    {
+        defect: "D10",
+        calendar: "ethioaa",
+        name: "fieldsFarMonth12",
+        expected: "+012704-11-25",
+        run: () => fieldsToIso("ethioaa", 18196, 12, 30),
+    },
+    {
+        defect: "D11",
+        calendar: "iso8601",
+        name: "totalMonthFromDay31",
+        expected: "1.0161290322580645",
+        run: () => monthTotal("2024-01-31T00:00:00", "2024-02-29T12:00:00"),
+    },
+    {
+        defect: "D11",
+        calendar: "iso8601",
+        name: "totalMonthFromDay31ShortTarget",
+        expected: "1.0161290322580645",
+        run: () => monthTotal("2023-01-31T00:00:00", "2023-02-28T12:00:00"),
+    },
+    {
+        defect: "D11",
+        calendar: "iso8601",
+        name: "totalMonthFromDay31ThirtyDayTarget",
+        expected: "1.0161290322580645",
+        run: () => monthTotal("2024-03-31T00:00:00", "2024-04-30T12:00:00"),
+    },
+    {
+        defect: "D11",
+        calendar: "iso8601",
+        name: "roundMonthFromDay31Floor",
+        expected: "P1M",
+        run: () => monthRound("P29DT12H", "2024-01-31", "floor"),
+    },
+    {
+        defect: "D11",
+        calendar: "iso8601",
+        name: "roundMonthFromDay30Ceil",
+        expected: "P2M",
+        run: () => monthRound("P30DT12H", "2024-01-30", "ceil"),
+    },
+    {
+        defect: "D11",
+        calendar: "iso8601",
+        name: "untilMonthFromDay31Trunc",
+        expected: "P1M",
+        run: () => monthUntil("2024-01-31T00:00:00", "2024-02-29T12:00:00", "trunc"),
+    },
+];
+/**
+ * `Duration#total({ unit: "month" })` for the span between two ISO datetimes, as a string.
+ *
+ * TC39 TotalRelativeDuration divides the leftover by the length of the month the *end* falls in —
+ * the span from `relativeTo` plus the whole months to `relativeTo` plus one more. The polyfill
+ * divides by the month that ends there instead, so any `relativeTo` on the 29th, 30th or 31st,
+ * where adding a month constrains the day, gets a fraction over the wrong denominator.
+ */
+function monthTotal(start, end) {
+    const from = Temporal.PlainDateTime.from(start);
+    return String(from
+        .until(Temporal.PlainDateTime.from(end), { largestUnit: "month" })
+        .total({ unit: "month", relativeTo: from }));
+}
+/**
+ * `Duration#round` and `PlainDateTime#until` to a calendar unit, as strings.
+ *
+ * Same window as `monthTotal`: the directed rounding modes take the answer from whichever bound the
+ * target sits nearest, so a window that does not contain the target loses a whole unit rather than a
+ * fraction of one.
+ */
+function monthRound(duration, relativeTo, roundingMode) {
+    return Temporal.Duration.from(duration)
+        .round({
+        smallestUnit: "month",
+        roundingMode,
+        relativeTo: Temporal.PlainDate.from(relativeTo),
+    })
+        .toString();
+}
+function monthUntil(start, end, roundingMode) {
+    return Temporal.PlainDateTime.from(start)
+        .until(Temporal.PlainDateTime.from(end), {
+        largestUnit: "month",
+        smallestUnit: "month",
+        roundingMode,
+    })
+        .toString();
+}
+function isoOf(date) {
+    return date.withCalendar("iso8601").toString();
+}
+function monthsUntil(calendar, from, to) {
+    return Temporal.PlainDate.from(from)
+        .withCalendar(calendar)
+        .until(Temporal.PlainDate.from(to).withCalendar(calendar), {
+        largestUnit: "months",
+    })
+        .toString();
+}
+/**
+ * D1 in add and until: the same out-of-range probe as fields → ISO. Expected values are Chromium 152
+ * native Temporal (q2-xscan-chromium152.json): `until(+275760-07-01, max)` is `edge.max[74]`, the
+ * add rows are `edge.buddhist.max[366]` and `edge["islamic-civil"].min[400]`.
+ */
+const d1ArithmeticRepros = [
+    ...[
+        ["hebrew", "P2M15D"],
+        ["buddhist", "P2M12D"],
+        ["islamic-civil", "P2M15D"],
+        ["islamic-tbla", "P2M15D"],
+        ["islamic-umalqura", "P2M15D"],
+        ["persian", "P2M12D"],
+        ["indian", "P2M12D"],
+        ["ethioaa", "P2M14D"],
+    ].map(([calendar, expected]) => ({
+        defect: "D1",
+        calendar,
+        name: "untilNearMax",
+        expected,
+        run: () => monthsUntil(calendar, "+275760-07-01", MAX_ISO),
+    })),
+    {
+        defect: "D1",
+        calendar: "buddhist",
+        name: "addNearMax",
+        expected: MAX_ISO,
+        run: () => isoOf(Temporal.PlainDate.from("+275759-09-13")
+            .withCalendar("buddhist")
+            .add({ years: 1 })),
+    },
+    {
+        defect: "D1",
+        calendar: "islamic-civil",
+        name: "subtractNearMin",
+        expected: "-271821-06-03",
+        run: () => isoOf(Temporal.PlainDate.from("-271820-05-23")
+            .withCalendar("islamic-civil")
+            .subtract({ years: 1 })),
+    },
+];
+/**
+ * D6: `until` re-constrains the day while counting months. The spec's NonISODateSurpasses compares
+ * the un-constrained day, so a month-end start does not reach a shorter month's end. Hebrew and
+ * ethioaa are test262 `wrapping-at-end-of-month-{hebrew,ethioaa}.js`; the rest are Chromium 152
+ * (q2-grid-chromium152.json, the first D6 row of each calendar), and gregory is Chromium 153
+ * (added to `CalendarSystem` in CORE-8; gregory months and days are ISO's, and ISO's own
+ * `ISODateSurpasses` gives the same P30D).
+ */
+const d6Repros = [
+    ...[
+        ["buddhist", "2023-08-31", "2023-09-30", "P30D"],
+        ["gregory", "2023-08-31", "2023-09-30", "P30D"],
+        ["japanese", "2023-08-31", "2023-09-30", "P30D"],
+        ["roc", "2023-08-31", "2023-09-30", "P30D"],
+        ["persian", "2023-09-22", "2023-10-22", "P30D"],
+        ["indian", "2023-09-22", "2023-10-22", "P30D"],
+        ["islamic-civil", "2023-06-19", "2023-07-18", "P29D"],
+        ["islamic-tbla", "2023-06-18", "2023-07-17", "P29D"],
+        ["islamic-umalqura", "2023-07-18", "2023-08-16", "P29D"],
+    ].map(([calendar, from, to, expected]) => ({
+        defect: "D6",
+        calendar,
+        name: "monthEnd",
+        expected,
+        run: () => monthsUntil(calendar, from, to),
+    })),
+    ...[
+        ["hebrew", 5783, "M07", 30, "M08", 29, "P29D"],
+        ["ethioaa", 1970, "M12", 28, "M13", 5, "P7D"],
+    ].map(([calendar, year, fromCode, fromDay, toCode, toDay, expected]) => ({
+        defect: "D6",
+        calendar,
+        name: "monthEnd",
+        expected,
+        run: () => Temporal.PlainDate.from({ calendar, year, monthCode: fromCode, day: fromDay }, { overflow: "reject" })
+            .until(Temporal.PlainDate.from({ calendar, year, monthCode: toCode, day: toDay }, { overflow: "reject" }), { largestUnit: "months" })
+            .toString(),
+    })),
+];
+/**
+ * D7: `until` with `largestUnit: "years"` from a leap-year `M05L` date throws "mixed-sign"
+ * (tc39/proposal-temporal#3159). Chromium 152: ISO 2024-02-11 + 384 days is `P12M29D`.
+ */
+const d7Repro = {
+    defect: "D7",
+    calendar: "hebrew",
+    name: "mixedSign",
+    expected: "P12M29D",
+    run: () => Temporal.PlainDate.from({
+        calendar: "hebrew",
+        year: 5784,
+        month: 6,
+        day: 2,
+    })
+        .until(Temporal.PlainDate.from({
+        calendar: "hebrew",
+        year: 5785,
+        month: 6,
+        day: 1,
+    }), { largestUnit: "years" })
+        .toString(),
+};
+/**
+ * D7, the leap-month end: from the last day of `M05L` (Adar I 30) in leap year 5784 to Adar 29 of
+ * common year 5785, by years. The intermediate `5784-M05L-30 + 1 year` constrains to Adar 29, which
+ * equals the end date, so upstream counts a whole year; `NonISODateSurpasses` compares the
+ * unconstrained day (30 > 29) and gives `P12M29D`. Spec and Chromium: `P12M29D`. Polyfill 0.5.1
+ * returns `P1Y`, and so does a js-temporal main build with `10aeb98` + `0e32ee0`: the `mixedSign`
+ * probe alone would report D7 removable while this row is still wrong
+ * (`context/domination/js-temporal-polyfill-bugs.md` § C, C-D7b).
+ */
+const d7LeapMonthEndRepro = {
+    defect: "D7",
+    calendar: "hebrew",
+    name: "leapMonthEnd",
+    expected: "P12M29D",
+    run: () => Temporal.PlainDate.from({
+        calendar: "hebrew",
+        year: 5784,
+        monthCode: "M05L",
+        day: 30,
+    })
+        .until(Temporal.PlainDate.from({
+        calendar: "hebrew",
+        year: 5785,
+        monthCode: "M06",
+        day: 29,
+    }), { largestUnit: "years" })
+        .toString(),
+};
+/**
+ * D1 in `Duration` rounding: a calendared `relativeTo` near the maximum reaches the same fields ->
+ * ISO probe. Chromium 153: P40D from Hebrew 279517-08-15 is 1 month (M08 has 30 days) and 10 days.
+ */
+const d1RelativeToRepro = {
+    defect: "D1",
+    calendar: "hebrew",
+    name: "relativeTo",
+    expected: "P1M10D",
+    run: () => Temporal.Duration.from("P40D")
+        .round({
+        largestUnit: "months",
+        relativeTo: Temporal.PlainDate.from({
+            calendar: "hebrew",
+            year: 279517,
+            month: 8,
+            day: 15,
+        }),
+    })
+        .toString(),
+};
+function readRepro(defect, calendar, iso, expected) {
+    return {
+        defect,
+        calendar,
+        name: iso,
+        expected,
+        run: () => readFields(iso, calendar),
+    };
+}
+const MAX_EPOCH_NANOSECONDS = 8640000000000000000000n;
+const MIN_EPOCH_NANOSECONDS = -MAX_EPOCH_NANOSECONDS;
+const NANOSECONDS_PER_DAY = 86400000000000n;
+const NANOSECONDS_PER_HOUR = 3600000000000n;
+function zoned(epochNanoseconds, timeZone) {
+    return new Temporal.ZonedDateTime(epochNanoseconds, timeZone);
+}
+function zonedRepro(defect, name, expected, run) {
+    return {
+        defect,
+        calendar: "iso8601",
+        name,
+        expected,
+        run: () => String(run()),
+    };
+}
+/** The error class a call throws, or `returned <value>` when it does not throw. */
+function thrownErrorName(run) {
+    try {
+        return `returned ${String(run())}`;
+    }
+    catch (error) {
+        return error instanceof Error ? error.name : String(error);
+    }
+}
+const SYDNEY_NEAR_MAX = MAX_EPOCH_NANOSECONDS - 3n * NANOSECONDS_PER_DAY - 5n * NANOSECONDS_PER_HOUR;
+/**
+ * zoned.A (`internal/zonedWallClock.ts` defect 1): `GetNamedTimeZoneEpochNanoseconds` clamps its
+ * offset probe to the wall clock's own UTC reading instead of the range limit. Polyfill 05ce7a3
+ * fixes the `max.*` rows only: a 0.5.1 build with it applied still throws for every `min.*` row, so
+ * this group must not be retired on the maximum alone. Expected values: Chromium 153 native Temporal
+ * (TC39 `DifferenceZonedDateTime`, `InterpretISODateTimeOffset`; upstream-issue draft A).
+ */
+const zonedARepros = [
+    zonedRepro("zoned.A", "max.parseSydney", "+275760-09-13T09:00:00+10:00[Australia/Sydney]", () => Temporal.ZonedDateTime.from("+275760-09-13T09:00:00+10:00[Australia/Sydney]")),
+    zonedRepro("zoned.A", "max.untilSydney", "P1D", () => zoned(MAX_EPOCH_NANOSECONDS - NANOSECONDS_PER_DAY, "Australia/Sydney").until(zoned(MAX_EPOCH_NANOSECONDS, "Australia/Sydney"), {
+        largestUnit: "day",
+    })),
+    zonedRepro("zoned.A", "max.sinceSydneyYears", "-P3DT5H", () => zoned(SYDNEY_NEAR_MAX, "Australia/Sydney").since(zoned(MAX_EPOCH_NANOSECONDS, "Australia/Sydney"), { largestUnit: "year" })),
+    zonedRepro("zoned.A", "max.untilKiritimati", "P1D", () => zoned(MAX_EPOCH_NANOSECONDS - NANOSECONDS_PER_DAY, "Pacific/Kiritimati").until(zoned(MAX_EPOCH_NANOSECONDS, "Pacific/Kiritimati"), {
+        largestUnit: "week",
+    })),
+    zonedRepro("zoned.A", "max.totalSydney", "2.0416666666666665", () => Temporal.Duration.from("PT49H").total({
+        unit: "day",
+        relativeTo: zoned(SYDNEY_NEAR_MAX, "Australia/Sydney"),
+    })),
+    zonedRepro("zoned.A", "max.compareSydney", "-1", () => Temporal.Duration.compare("P3D", "PT73H", {
+        relativeTo: zoned(SYDNEY_NEAR_MAX, "Australia/Sydney"),
+    })),
+    zonedRepro("zoned.A", "min.parseNewYork", "-271821-04-19T20:00:00-04:56[America/New_York]", () => Temporal.ZonedDateTime.from("-271821-04-19T20:00:00[America/New_York]")),
+    zonedRepro("zoned.A", "min.toZonedDateTimeNewYork", "-271821-04-19T20:00:00-04:56[America/New_York]", () => Temporal.PlainDateTime.from("-271821-04-19T20:00").toZonedDateTime("America/New_York")),
+    zonedRepro("zoned.A", "min.untilNewYork", "-P1D", () => zoned(MIN_EPOCH_NANOSECONDS + NANOSECONDS_PER_DAY, "America/New_York").until(zoned(MIN_EPOCH_NANOSECONDS, "America/New_York"), {
+        largestUnit: "day",
+    })),
+    zonedRepro("zoned.A", "min.untilHonolulu", "-P1D", () => zoned(MIN_EPOCH_NANOSECONDS + NANOSECONDS_PER_DAY, "Pacific/Honolulu").until(zoned(MIN_EPOCH_NANOSECONDS, "Pacific/Honolulu"), {
+        largestUnit: "day",
+    })),
+];
+/** America/Santiago's last transition before the maximum (-04:00 → -03:00, local midnight skipped). */
+const SANTIAGO_LAST_TRANSITION = "+275760-09-07T01:00:00-03:00[America/Santiago]";
+/**
+ * zoned.B (`internal/zonedWallClock.ts` defect 2): `GetNamedTimeZoneNextTransition` returns null
+ * once a search step would pass the maximum, so a transition in the range's last two weeks is
+ * missed and `GetStartOfDay` dereferences that null. Not fixed on the polyfill's main branch.
+ * Expected values: Chromium 153 (TC39 `GetNamedTimeZoneNextTransition`, `GetStartOfDay`).
+ */
+const zonedBRepros = [
+    zonedRepro("zoned.B", "max.nextTransition", SANTIAGO_LAST_TRANSITION, () => Temporal.Instant.from("+275760-09-01T00:00:00Z")
+        .toZonedDateTimeISO("America/Santiago")
+        .getTimeZoneTransition("next")),
+    zonedRepro("zoned.B", "max.startOfDaySantiago", SANTIAGO_LAST_TRANSITION, () => Temporal.PlainDate.from("+275760-09-07").toZonedDateTime("America/Santiago")),
+    zonedRepro("zoned.B", "max.hoursInDaySantiago", "23", () => Temporal.ZonedDateTime.from("+275760-09-07T12:00[America/Santiago]")
+        .hoursInDay),
+];
+/**
+ * zoned.D (`internal/zonedWallClockDifference.ts` defect 2): the `"UTC"` fast path of
+ * `GetPossibleEpochNanoseconds` skips `IsValidEpochNanoseconds`, so a UTC rounding or total window
+ * ending past the maximum returns a value where TC39 throws. Not fixed on the polyfill's main
+ * branch. Expected: RangeError, as Chromium 153 throws (and the polyfill does for `+00:00`).
+ */
+const zonedDRepros = [
+    zonedRepro("zoned.D", "max.untilUtcRounded", "RangeError", () => thrownErrorName(() => zoned(SYDNEY_NEAR_MAX, "UTC").until(zoned(MAX_EPOCH_NANOSECONDS, "UTC"), {
+        largestUnit: "day",
+        smallestUnit: "hour",
+    }))),
+    zonedRepro("zoned.D", "max.totalUtc", "RangeError", () => thrownErrorName(() => Temporal.Duration.from("PT49H").total({
+        unit: "day",
+        relativeTo: zoned(MAX_EPOCH_NANOSECONDS -
+            2n * NANOSECONDS_PER_DAY -
+            NANOSECONDS_PER_HOUR, "UTC"),
+    }))),
+];
+/** Asia/Manila's 1844-12-31 date-line crossing (−15:56:08 → +08:03:52), as Chromium 153 prints it. */
+const MANILA_CROSSING = "1845-01-01T00:00:00+08:04[Asia/Manila]";
+/**
+ * zoned.E (`internal/zonedWallClock.ts` defect 3): `GetNamedTimeZoneNextTransition` and
+ * `…PreviousTransition` start their search at `BEFORE_FIRST_DST` = 1847-01-01, so the 1844-12-31
+ * date-line crossing of Asia/Manila, Pacific/Guam, Saipan, Kosrae and Palau is never found, and
+ * `GetStartOfDay` for the skipped 1844-12-31 returns the wrong `next`. js-temporal/temporal-polyfill
+ * #372 (tc39/proposal-temporal#3330). Expected values: Chromium 153 native Temporal.
+ * `previousGuam` asks from after the floor, so it also proves the backward search reaches past it.
+ */
+const zonedERepros = [
+    zonedRepro("zoned.E", "pre1847.nextManila", MANILA_CROSSING, () => Temporal.Instant.from("1800-01-01T00:00:00Z")
+        .toZonedDateTimeISO("Asia/Manila")
+        .getTimeZoneTransition("next")),
+    zonedRepro("zoned.E", "pre1847.previousManila", MANILA_CROSSING, () => Temporal.Instant.from("1846-01-01T00:00:00Z")
+        .toZonedDateTimeISO("Asia/Manila")
+        .getTimeZoneTransition("previous")),
+    zonedRepro("zoned.E", "pre1847.previousGuam", "1845-01-01T00:00:00+09:39[Pacific/Guam]", () => Temporal.Instant.from("1848-01-01T00:00:00Z")
+        .toZonedDateTimeISO("Pacific/Guam")
+        .getTimeZoneTransition("previous")),
+    zonedRepro("zoned.E", "pre1847.hoursInDayManila", "24", () => Temporal.ZonedDateTime.from("1844-12-30T12:00[Asia/Manila]").hoursInDay),
+    zonedRepro("zoned.E", "pre1847.startOfDayManila", MANILA_CROSSING, () => Temporal.PlainDate.from("1844-12-31").toZonedDateTime("Asia/Manila")),
+];
+/** More `Intl.DateTimeFormat#formatToParts` reads than this for 1,200 months is per-month work. */
+const D9_INTL_READ_LIMIT = 100;
+const D9_MONTHS = 1_200;
+/**
+ * `run()`'s output, or a note of how many `Intl.DateTimeFormat#formatToParts` calls it made when
+ * that is more than `D9_INTL_READ_LIMIT`. Polyfill 0.5.1 reads the calendar through that method
+ * once or more per month stepped; bounded arithmetic reads a handful of dates, or none.
+ */
+function withBoundedIntlReads(run) {
+    const prototype = Intl.DateTimeFormat.prototype;
+    const original = prototype.formatToParts;
+    let reads = 0;
+    prototype.formatToParts = function formatToParts(date) {
+        reads++;
+        return original.call(this, date);
+    };
+    try {
+        const output = run();
+        return reads <= D9_INTL_READ_LIMIT
+            ? output
+            : `${reads} Intl reads for ${D9_MONTHS} months`;
+    }
+    finally {
+        prototype.formatToParts = original;
+    }
+}
+/**
+ * D9: 1,200 months from month M03 day 5. Persian has 12 months in every year (Intl era/monthCode
+ * proposal §4.1.4 Table 3), so they are 100 years. Hebrew: the Dershowitz–Reingold month count
+ * `floor((235y − 234) / 19)` puts month 1,200 after 5784-M03 at 5881 ordinal 3, a common year, so
+ * `M03`.
+ */
+const d9Repros = [
+    ["persian", 1402, "1502|M03|5"],
+    ["hebrew", 5784, "5881|M03|5"],
+].flatMap(([calendar, year, expected]) => {
+    const start = () => Temporal.PlainDate.from({ calendar, year, month: 3, day: 5 });
+    const [endYear] = expected.split("|").map(Number);
+    return [
+        {
+            defect: "D9",
+            calendar,
+            name: "addMonths",
+            expected,
+            run: () => withBoundedIntlReads(() => {
+                const date = start().add({ months: D9_MONTHS });
+                return `${date.year}|${date.monthCode}|${date.day}`;
+            }),
+        },
+        {
+            defect: "D9",
+            calendar,
+            name: "untilMonths",
+            expected: `P${D9_MONTHS}M`,
+            run: () => withBoundedIntlReads(() => start()
+                .until(Temporal.PlainDate.from({
+                calendar,
+                year: endYear ?? Number.NaN,
+                monthCode: "M03",
+                day: 5,
+            }), { largestUnit: "months" })
+                .toString()),
+        },
+    ];
+});
+export const repros = [
+    ...d9Repros,
+    ...zonedARepros,
+    ...zonedBRepros,
+    ...zonedDRepros,
+    ...zonedERepros,
+    ...d1Repros,
+    ...d1ArithmeticRepros,
+    d1RelativeToRepro,
+    ...d10Repros,
+    ...d6Repros,
+    d7Repro,
+    d7LeapMonthEndRepro,
+    // D2: buddhist read through ICU4C's Julian/Gregorian hybrid. The Intl era/monthCode proposal
+    // makes buddhist proleptic with month and day identical to ISO; Chromium 152 agrees.
+    readRepro("D2", "buddhist", "1000-01-01", "1543|M01|1"),
+    readRepro("D2", "buddhist", "1582-10-04", "2125|M10|4"),
+    // D3: Hebrew `inLeapYear` uses JS `%` on negative years, so every year <= -1 is "leap".
+    // Year -96239 is common: (7 × -96239 + 1) mod 19 = 11, not < 7.
+    {
+        defect: "D3",
+        calendar: "hebrew",
+        name: "-100000-01-01",
+        expected: "12",
+        run: () => String(Temporal.PlainDate.from("-100000-01-01").withCalendar("hebrew")
+            .monthsInYear),
+    },
+    // D4: ICU4C Hebrew is one day off for years <= 0 (fixed in ICU 5267bb5778, ICU-23007).
+    // Chromium 152 and the Dershowitz–Reingold arithmetic agree on these days.
+    readRepro("D4", "hebrew", "-271821-11-05", "-268057|M05|28"),
+    readRepro("D4", "hebrew", "-003761-09-01", "0|M01|13"),
+    // D5: the polyfill's stale "V8 bug 10529" detector throws for every ISO year < 1.
+    readRepro("D5", "indian", "-000500-06-15", "-578|M03|25"),
+    // D8: pre-proposal era codes. test262 japanese-pre-meiji.js and the proposal's era table:
+    // `ce` up to 1872-12-31, `bce` for ISO years <= 0.
+    ...[
+        ["1800-01-01", "ce|1800"],
+        ["1872-12-31", "ce|1872"],
+        ["0000-12-31", "bce|1"],
+    ].map(([iso, expected]) => ({
+        defect: "D8",
+        calendar: "japanese",
+        name: iso,
+        expected,
+        run: () => {
+            const date = Temporal.PlainDate.from(iso).withCalendar("japanese");
+            return `${date.era}|${date.eraYear}`;
+        },
+    })),
+];
+/** The repro with this defect, calendar and name, if any. */
+export function findRepro(defect, calendar, name) {
+    return repros.find((repro) => repro.defect === defect &&
+        repro.calendar === calendar &&
+        repro.name === name);
+}

package/dist/internal/toInstantFromUtc.d.ts

@@ -1,2 +1,12 @@
 import { Temporal } from "@js-temporal/polyfill";
 export declare function toInstantFromUtc(value: string): Temporal.Instant | null;
+/**
+ * Resolve a `reference` option to an instant: the parsed UTC string when one is given, else now.
+ *
+ * @param reference a UTC ISO string the caller has validated, or undefined (and `""`) for now
+ * @returns the instant, or null when the string does not parse or the clock is unavailable
+ * @example toReferenceInstantFromUtc("2024-03-15T12:00:00Z")?.toString() // "2024-03-15T12:00:00Z"
+ * @example toReferenceInstantFromUtc(undefined) instanceof Temporal.Instant // true (now)
+ * @example toReferenceInstantFromUtc("not-a-date") // null
+ */
+export declare function toReferenceInstantFromUtc(reference: string | undefined): Temporal.Instant | null;

package/dist/internal/toInstantFromUtc.js

@@ -9,3 +9,22 @@ export function toInstantFromUtc(value) {
         return null;
     }
 }
+/**
+ * Resolve a `reference` option to an instant: the parsed UTC string when one is given, else now.
+ *
+ * @param reference a UTC ISO string the caller has validated, or undefined (and `""`) for now
+ * @returns the instant, or null when the string does not parse or the clock is unavailable
+ * @example toReferenceInstantFromUtc("2024-03-15T12:00:00Z")?.toString() // "2024-03-15T12:00:00Z"
+ * @example toReferenceInstantFromUtc(undefined) instanceof Temporal.Instant // true (now)
+ * @example toReferenceInstantFromUtc("not-a-date") // null
+ */
+export function toReferenceInstantFromUtc(reference) {
+    if (reference)
+        return toInstantFromUtc(reference);
+    try {
+        return Temporal.Now.instant();
+    }
+    catch {
+        return null;
+    }
+}