Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

25 files changed, 4427 insertions, 0 deletions

diff --git a/js/src/tests/test262/staging/Intl402/Temporal/browser.js b/js/src/tests/test262/staging/Intl402/Temporal/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/browser.js
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/addition-across-lunisolar-leap-months.js b/js/src/tests/test262/staging/Intl402/Temporal/old/addition-across-lunisolar-leap-months.js
new file mode 100644
index 0000000000..6e44e1974f
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/addition-across-lunisolar-leap-months.js
@@ -0,0 +1,96 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: Addition across lunisolar leap months
+features: [Temporal]
+---*/
+
+// Adding years across Hebrew leap month
+var date = Temporal.PlainDate.from({
+  year: 5783,
+  monthCode: "M08",
+  day: 2,
+  calendar: "hebrew"
+});
+var added = date.add({ years: 1 });
+assert.sameValue(added.monthCode, date.monthCode);
+assert.sameValue(added.year, date.year + 1);
+
+// Adding months across Hebrew leap month
+var date = Temporal.PlainDate.from({
+  year: 5783,
+  monthCode: "M08",
+  day: 2,
+  calendar: "hebrew"
+});
+var added = date.add({ months: 13 });
+assert.sameValue(added.monthCode, date.monthCode);
+assert.sameValue(added.year, date.year + 1);
+
+// Adding months and years across Hebrew leap month
+var date = Temporal.PlainDate.from({
+  year: 5783,
+  monthCode: "M08",
+  day: 2,
+  calendar: "hebrew"
+});
+var added = date.add({
+  years: 1,
+  months: 12
+});
+assert.sameValue(added.monthCode, date.monthCode);
+assert.sameValue(added.year, date.year + 2);
+var testChineseData = new Date("2001-02-01T00:00Z").toLocaleString("en-US-u-ca-chinese", {
+  day: "numeric",
+  month: "numeric",
+  year: "numeric",
+  era: "short",
+  timeZone: "UTC"
+});
+var hasOutdatedChineseIcuData = !testChineseData.endsWith("2001");
+
+// Adding years across Chinese leap month"
+if(hasOutdatedChineseIcuData) {
+  var date = Temporal.PlainDate.from({
+    year: 2000,
+    monthCode: "M08",
+    day: 2,
+    calendar: "chinese"
+  });
+  var added = date.add({ years: 1 });
+  assert.sameValue(added.monthCode, date.monthCode);
+  assert.sameValue(added.year, date.year + 1);
+}
+// Adding months across Chinese leap month
+if(hasOutdatedChineseIcuData) {
+  var date = Temporal.PlainDate.from({
+    year: 2000,
+    monthCode: "M08",
+    day: 2,
+    calendar: "chinese"
+  });
+  var added = date.add({ months: 13 });
+  assert.sameValue(added.monthCode, date.monthCode);
+  assert.sameValue(added.year, date.year + 1);
+}
+
+// Adding months and years across Chinese leap month
+if(hasOutdatedChineseIcuData) {
+  var date = Temporal.PlainDate.from({
+    year: 2001,
+    monthCode: "M08",
+    day: 2,
+    calendar: "chinese"
+  });
+  var added = date.add({
+    years: 1,
+    months: 12
+  });
+  assert.sameValue(added.monthCode, date.monthCode);
+  assert.sameValue(added.year, date.year + 2);
+};
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/browser.js b/js/src/tests/test262/staging/Intl402/Temporal/old/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/browser.js
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/date-time-format.js b/js/src/tests/test262/staging/Intl402/Temporal/old/date-time-format.js
new file mode 100644
index 0000000000..2729754353
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/date-time-format.js
@@ -0,0 +1,1668 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: DateTimeFormat
+includes: [deepEqual.js]
+features: [Temporal]
+---*/
+
+// Tolerate implementation variance by expecting consistency without being prescriptive.
+// TODO: can we change tests to be less reliant on CLDR formats while still testing that
+// Temporal and Intl are behaving as expected?
+const usDayPeriodSpace =
+  new Intl.DateTimeFormat("en-US", { timeStyle: "short" })
+    .formatToParts(0)
+    .find((part, i, parts) => part.type === "literal" && parts[i + 1].type === "dayPeriod")?.value || "";
+const usDateRangeSeparator = new Intl.DateTimeFormat("en-US", { dateStyle: "short" })
+  .formatRangeToParts(1 * 86400 * 1000, 366 * 86400 * 1000)
+  .find((part) => part.type === "literal" && part.source === "shared").value;
+const deDateRangeSeparator = new Intl.DateTimeFormat("de-AT", { dateStyle: "short" })
+  .formatRangeToParts(1 * 86400 * 1000, 366 * 86400 * 1000)
+  .find((part) => part.type === "literal" && part.source === "shared").value;
+
+// Workarounds for https:// unicode-org.atlassian.net/browse/CLDR-16243
+const deMonthDayRangeSeparator = new Intl.DateTimeFormat("de-AT", { month: "numeric", day: "numeric" })
+  .formatRangeToParts(1 * 86400 * 1000, 90 * 86400 * 1000)
+  .find((part) => part.type === "literal" && part.source === "shared").value;
+const deMonthYearSeparator = new Intl.DateTimeFormat("de-AT", { year: "numeric", month: "numeric" })
+  .formatToParts(0)
+  .find((part) => part.type === "literal").value;
+const deMonthInYearMonthHasLeadingZero = new Intl.DateTimeFormat("de-AT", {
+  year: "numeric",
+  month: "numeric"
+})
+  .formatToParts(new Date(2000, 3, 1))
+  .find((part) => part.type === "month")
+  .value.startsWith("0");
+
+// should return an Array
+assert(Array.isArray(Intl.DateTimeFormat.supportedLocalesOf()));
+var onlyOnce = (value) => {
+  var obj = {
+    calls: 0,
+    toString() {
+      if (++this.calls > 1) throw new RangeError("prop read twice");
+      return value;
+    }
+  };
+  return obj;
+};
+var optionsAT = { timeZone: onlyOnce("Europe/Vienna") };
+var optionsUS = {
+  calls: 0,
+  value: "America/New_York",
+  get timeZone() {
+    if (++this.calls > 1) throw new RangeError("prop read twice");
+    return this.value;
+  },
+  set timeZone(val) {
+    this.value = val;
+  }
+};
+var localesAT = ["de-AT"];
+var us = new Intl.DateTimeFormat("en-US", optionsUS);
+var at = new Intl.DateTimeFormat(localesAT, optionsAT);
+optionsAT.timeZone = {
+  toString: () => "Bogus/Time-Zone",
+  toJSON: () => "Bogus/Time-Zone"
+};
+optionsUS.timeZone = "Bogus/Time-Zone";
+var us2 = new Intl.DateTimeFormat("en-US");
+var at2 = new Intl.DateTimeFormat(localesAT);
+localesAT[0] = ["invalid locale"];
+var usCalendar = us.resolvedOptions().calendar;
+var atCalendar = at.resolvedOptions().calendar;
+var t1 = "1976-11-18T14:23:30+00:00[UTC]";
+var t2 = "2020-02-20T15:44:56-05:00[America/New_York]";
+var start = new Date("1922-12-30");
+var end = new Date("1991-12-26");
+
+// should work for Instant
+assert.sameValue(us.format(Temporal.Instant.from(t1)), `11/18/1976, 9:23:30${usDayPeriodSpace}AM`);
+assert.sameValue(at.format(Temporal.Instant.from(t1)), "18.11.1976, 15:23:30");
+
+// should work for DateTime
+assert.sameValue(us.format(Temporal.PlainDateTime.from(t1)), `11/18/1976, 2:23:30${usDayPeriodSpace}PM`);
+assert.sameValue(at.format(Temporal.PlainDateTime.from(t1)), "18.11.1976, 14:23:30");
+
+// should work for Time
+assert.sameValue(us.format(Temporal.PlainTime.from(t1)), `2:23:30${usDayPeriodSpace}PM`);
+assert.sameValue(at.format(Temporal.PlainTime.from(t1)), "14:23:30");
+
+// should work for Date
+assert.sameValue(us.format(Temporal.PlainDate.from(t1)), "11/18/1976");
+assert.sameValue(at.format(Temporal.PlainDate.from(t1)), "18.11.1976");
+
+// should work for YearMonth
+var t = Temporal.PlainDate.from(t1);
+assert.sameValue(us.format(t.withCalendar(usCalendar).toPlainYearMonth()), "11/1976");
+assert.sameValue(at.format(t.withCalendar(atCalendar).toPlainYearMonth()), `11${deMonthYearSeparator}1976`);
+
+// should work for MonthDay
+var t = Temporal.PlainDate.from(t1);
+assert.sameValue(us.format(t.withCalendar(usCalendar).toPlainMonthDay()), "11/18");
+assert.sameValue(at.format(t.withCalendar(atCalendar).toPlainMonthDay()), "18.11.");
+
+// should not break legacy Date
+assert.sameValue(us.format(start), "12/29/1922");
+assert.sameValue(at.format(start), "30.12.1922");
+
+// should work for Instant
+assert.deepEqual(us.formatToParts(Temporal.Instant.from(t2)), [
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "day",
+    value: "20"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "year",
+    value: "2020"
+  },
+  {
+    type: "literal",
+    value: ", "
+  },
+  {
+    type: "hour",
+    value: "3"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "minute",
+    value: "44"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "second",
+    value: "56"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace
+  },
+  {
+    type: "dayPeriod",
+    value: "PM"
+  }
+]);
+assert.deepEqual(at.formatToParts(Temporal.Instant.from(t2)), [
+  {
+    type: "day",
+    value: "20"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "year",
+    value: "2020"
+  },
+  {
+    type: "literal",
+    value: ", "
+  },
+  {
+    type: "hour",
+    value: "21"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "minute",
+    value: "44"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "second",
+    value: "56"
+  }
+]);
+// should work for DateTime
+assert.deepEqual(us.formatToParts(Temporal.PlainDateTime.from(t2)), [
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "day",
+    value: "20"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "year",
+    value: "2020"
+  },
+  {
+    type: "literal",
+    value: ", "
+  },
+  {
+    type: "hour",
+    value: "3"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "minute",
+    value: "44"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "second",
+    value: "56"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace
+  },
+  {
+    type: "dayPeriod",
+    value: "PM"
+  }
+]);
+assert.deepEqual(at.formatToParts(Temporal.PlainDateTime.from(t2)), [
+  {
+    type: "day",
+    value: "20"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "year",
+    value: "2020"
+  },
+  {
+    type: "literal",
+    value: ", "
+  },
+  {
+    type: "hour",
+    value: "15"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "minute",
+    value: "44"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "second",
+    value: "56"
+  }
+]);
+// should work for Time
+assert.deepEqual(us.formatToParts(Temporal.PlainTime.from(t2)), [
+  {
+    type: "hour",
+    value: "3"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "minute",
+    value: "44"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "second",
+    value: "56"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace
+  },
+  {
+    type: "dayPeriod",
+    value: "PM"
+  }
+]);
+assert.deepEqual(at.formatToParts(Temporal.PlainTime.from(t2)), [
+  {
+    type: "hour",
+    value: "15"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "minute",
+    value: "44"
+  },
+  {
+    type: "literal",
+    value: ":"
+  },
+  {
+    type: "second",
+    value: "56"
+  }
+]);
+// should work for Date
+assert.deepEqual(us.formatToParts(Temporal.PlainDate.from(t2)), [
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "day",
+    value: "20"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "year",
+    value: "2020"
+  }
+]);
+assert.deepEqual(at.formatToParts(Temporal.PlainDate.from(t2)), [
+  {
+    type: "day",
+    value: "20"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "year",
+    value: "2020"
+  }
+]);
+// should work for YearMonth
+var t = Temporal.PlainDate.from(t2);
+assert.deepEqual(us.formatToParts(t.withCalendar(usCalendar).toPlainYearMonth()), [
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "year",
+    value: "2020"
+  }
+]);
+assert.deepEqual(at.formatToParts(t.withCalendar(atCalendar).toPlainYearMonth()), [
+  {
+    type: "month",
+    value: deMonthInYearMonthHasLeadingZero ? "02" : "2"
+  },
+  {
+    type: "literal",
+    value: deMonthYearSeparator
+  },
+  {
+    type: "year",
+    value: "2020"
+  }
+]);
+// should work for MonthDay
+var t = Temporal.PlainDate.from(t2);
+assert.deepEqual(us.formatToParts(t.withCalendar(usCalendar).toPlainMonthDay()), [
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "day",
+    value: "20"
+  }
+]);
+assert.deepEqual(at.formatToParts(t.withCalendar(atCalendar).toPlainMonthDay()), [
+  {
+    type: "day",
+    value: "20"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "month",
+    value: "2"
+  },
+  {
+    type: "literal",
+    value: "."
+  }
+]);
+// should not break legacy Date
+assert.deepEqual(us.formatToParts(end), [
+  {
+    type: "month",
+    value: "12"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "day",
+    value: "25"
+  },
+  {
+    type: "literal",
+    value: "/"
+  },
+  {
+    type: "year",
+    value: "1991"
+  }
+]);
+assert.deepEqual(at.formatToParts(end), [
+  {
+    type: "day",
+    value: "26"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "month",
+    value: "12"
+  },
+  {
+    type: "literal",
+    value: "."
+  },
+  {
+    type: "year",
+    value: "1991"
+  }
+]);
+// formatRange
+// should work for Instant
+assert.sameValue(
+  us.formatRange(Temporal.Instant.from(t1), Temporal.Instant.from(t2)),
+  `11/18/1976, 9:23:30${usDayPeriodSpace}AM${usDateRangeSeparator}2/20/2020, 3:44:56${usDayPeriodSpace}PM`
+);
+assert.sameValue(
+  at.formatRange(Temporal.Instant.from(t1), Temporal.Instant.from(t2)),
+  `18.11.1976, 15:23:30${deDateRangeSeparator}20.2.2020, 21:44:56`
+);
+
+// should work for DateTime
+assert.sameValue(
+  us.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)),
+  `11/18/1976, 2:23:30${usDayPeriodSpace}PM${usDateRangeSeparator}2/20/2020, 3:44:56${usDayPeriodSpace}PM`
+);
+assert.sameValue(
+  at.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)),
+  `18.11.1976, 14:23:30${deDateRangeSeparator}20.2.2020, 15:44:56`
+);
+
+// should work for Time
+assert.sameValue(
+  us.formatRange(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)),
+  `2:23:30${usDayPeriodSpace}PM${usDateRangeSeparator}3:44:56${usDayPeriodSpace}PM`
+);
+assert.sameValue(
+  at.formatRange(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)),
+  `14:23:30${deDateRangeSeparator}15:44:56`
+);
+
+// should work for Date
+assert.sameValue(
+  us.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)),
+  `11/18/1976${usDateRangeSeparator}2/20/2020`
+);
+assert.sameValue(
+  at.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)),
+  `18.11.1976${deDateRangeSeparator}20.02.2020`
+);
+
+// should work for YearMonth
+var date1 = Temporal.PlainDate.from(t1);
+var date2 = Temporal.PlainDate.from(t2);
+assert.sameValue(
+  us.formatRange(date1.withCalendar(usCalendar).toPlainYearMonth(), date2.withCalendar(usCalendar).toPlainYearMonth()),
+  `11/1976${usDateRangeSeparator}2/2020`
+);
+assert.sameValue(
+  at.formatRange(date1.withCalendar(atCalendar).toPlainYearMonth(), date2.withCalendar(atCalendar).toPlainYearMonth()),
+  `11${deMonthYearSeparator}1976${deDateRangeSeparator}02${deMonthYearSeparator}2020`
+);
+
+// should work for MonthDay
+var date1 = Temporal.PlainDate.from(t1);
+var date2 = Temporal.PlainDate.from(t2);
+assert.sameValue(
+  us.formatRange(date2.withCalendar(usCalendar).toPlainMonthDay(), date1.withCalendar(usCalendar).toPlainMonthDay()),
+  `2/20${usDateRangeSeparator}11/18`
+);
+assert.sameValue(
+  at.formatRange(date2.withCalendar(atCalendar).toPlainMonthDay(), date1.withCalendar(atCalendar).toPlainMonthDay()),
+  `20.02${deMonthDayRangeSeparator}18.11.`
+);
+
+// should not break legacy Date
+assert.sameValue(us.formatRange(start, end), `12/29/1922${usDateRangeSeparator}12/25/1991`);
+assert.sameValue(at.formatRange(start, end), `30.12.1922${deDateRangeSeparator}26.12.1991`);
+
+// should throw a RangeError when called with different calendars
+assert.throws(RangeError, () =>
+  us.formatRange(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2).withCalendar("japanese"))
+);
+assert.throws(RangeError, () =>
+  us.formatRange(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2).withCalendar("japanese"))
+);
+
+// formatRangeToParts
+// should work for Instant
+assert.deepEqual(us.formatRangeToParts(Temporal.Instant.from(t1), Temporal.Instant.from(t2)), [
+  {
+    type: "month",
+    value: "11",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "startRange"
+  },
+  {
+    type: "day",
+    value: "18",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "startRange"
+  },
+  {
+    type: "year",
+    value: "1976",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ", ",
+    source: "startRange"
+  },
+  {
+    type: "hour",
+    value: "9",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "minute",
+    value: "23",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "second",
+    value: "30",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace,
+    source: "startRange"
+  },
+  {
+    type: "dayPeriod",
+    value: "AM",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: usDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "month",
+    value: "2",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "endRange"
+  },
+  {
+    type: "day",
+    value: "20",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "endRange"
+  },
+  {
+    type: "year",
+    value: "2020",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ", ",
+    source: "endRange"
+  },
+  {
+    type: "hour",
+    value: "3",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "minute",
+    value: "44",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "second",
+    value: "56",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace,
+    source: "endRange"
+  },
+  {
+    type: "dayPeriod",
+    value: "PM",
+    source: "endRange"
+  }
+]);
+assert.deepEqual(at.formatRangeToParts(Temporal.Instant.from(t1), Temporal.Instant.from(t2)), [
+  {
+    type: "day",
+    value: "18",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "startRange"
+  },
+  {
+    type: "month",
+    value: "11",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "startRange"
+  },
+  {
+    type: "year",
+    value: "1976",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ", ",
+    source: "startRange"
+  },
+  {
+    type: "hour",
+    value: "15",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "minute",
+    value: "23",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "second",
+    value: "30",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: deDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "day",
+    value: "20",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "endRange"
+  },
+  {
+    type: "month",
+    value: "2",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "endRange"
+  },
+  {
+    type: "year",
+    value: "2020",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ", ",
+    source: "endRange"
+  },
+  {
+    type: "hour",
+    value: "21",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "minute",
+    value: "44",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "second",
+    value: "56",
+    source: "endRange"
+  }
+]);
+// should work for DateTime
+assert.deepEqual(us.formatRangeToParts(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)), [
+  {
+    type: "month",
+    value: "11",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "startRange"
+  },
+  {
+    type: "day",
+    value: "18",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "startRange"
+  },
+  {
+    type: "year",
+    value: "1976",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ", ",
+    source: "startRange"
+  },
+  {
+    type: "hour",
+    value: "2",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "minute",
+    value: "23",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "second",
+    value: "30",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace,
+    source: "startRange"
+  },
+  {
+    type: "dayPeriod",
+    value: "PM",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: usDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "month",
+    value: "2",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "endRange"
+  },
+  {
+    type: "day",
+    value: "20",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "endRange"
+  },
+  {
+    type: "year",
+    value: "2020",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ", ",
+    source: "endRange"
+  },
+  {
+    type: "hour",
+    value: "3",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "minute",
+    value: "44",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "second",
+    value: "56",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace,
+    source: "endRange"
+  },
+  {
+    type: "dayPeriod",
+    value: "PM",
+    source: "endRange"
+  }
+]);
+assert.deepEqual(at.formatRangeToParts(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2)), [
+  {
+    type: "day",
+    value: "18",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "startRange"
+  },
+  {
+    type: "month",
+    value: "11",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "startRange"
+  },
+  {
+    type: "year",
+    value: "1976",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ", ",
+    source: "startRange"
+  },
+  {
+    type: "hour",
+    value: "14",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "minute",
+    value: "23",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "second",
+    value: "30",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: deDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "day",
+    value: "20",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "endRange"
+  },
+  {
+    type: "month",
+    value: "2",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "endRange"
+  },
+  {
+    type: "year",
+    value: "2020",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ", ",
+    source: "endRange"
+  },
+  {
+    type: "hour",
+    value: "15",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "minute",
+    value: "44",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "second",
+    value: "56",
+    source: "endRange"
+  }
+]);
+// should work for Time
+assert.deepEqual(us.formatRangeToParts(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)), [
+  {
+    type: "hour",
+    value: "2",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "minute",
+    value: "23",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "second",
+    value: "30",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace,
+    source: "startRange"
+  },
+  {
+    type: "dayPeriod",
+    value: "PM",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: usDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "hour",
+    value: "3",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "minute",
+    value: "44",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "second",
+    value: "56",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: usDayPeriodSpace,
+    source: "endRange"
+  },
+  {
+    type: "dayPeriod",
+    value: "PM",
+    source: "endRange"
+  }
+]);
+assert.deepEqual(at.formatRangeToParts(Temporal.PlainTime.from(t1), Temporal.PlainTime.from(t2)), [
+  {
+    type: "hour",
+    value: "14",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "minute",
+    value: "23",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "startRange"
+  },
+  {
+    type: "second",
+    value: "30",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: deDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "hour",
+    value: "15",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "minute",
+    value: "44",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ":",
+    source: "endRange"
+  },
+  {
+    type: "second",
+    value: "56",
+    source: "endRange"
+  }
+]);
+// should work for Date
+assert.deepEqual(us.formatRangeToParts(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)), [
+  {
+    type: "month",
+    value: "11",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "startRange"
+  },
+  {
+    type: "day",
+    value: "18",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "startRange"
+  },
+  {
+    type: "year",
+    value: "1976",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: usDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "month",
+    value: "2",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "endRange"
+  },
+  {
+    type: "day",
+    value: "20",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "endRange"
+  },
+  {
+    type: "year",
+    value: "2020",
+    source: "endRange"
+  }
+]);
+assert.deepEqual(at.formatRangeToParts(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2)), [
+  {
+    type: "day",
+    value: "18",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "startRange"
+  },
+  {
+    type: "month",
+    value: "11",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "startRange"
+  },
+  {
+    type: "year",
+    value: "1976",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: deDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "day",
+    value: "20",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "endRange"
+  },
+  {
+    type: "month",
+    value: "02",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "endRange"
+  },
+  {
+    type: "year",
+    value: "2020",
+    source: "endRange"
+  }
+]);
+// should work for YearMonth
+var date1 = Temporal.PlainDate.from(t1);
+var date2 = Temporal.PlainDate.from(t2);
+assert.deepEqual(
+  us.formatRangeToParts(
+    date1.withCalendar(usCalendar).toPlainYearMonth(),
+    date2.withCalendar(usCalendar).toPlainYearMonth()
+  ),
+  [
+    {
+      type: "month",
+      value: "11",
+      source: "startRange"
+    },
+    {
+      type: "literal",
+      value: "/",
+      source: "startRange"
+    },
+    {
+      type: "year",
+      value: "1976",
+      source: "startRange"
+    },
+    {
+      type: "literal",
+      value: usDateRangeSeparator,
+      source: "shared"
+    },
+    {
+      type: "month",
+      value: "2",
+      source: "endRange"
+    },
+    {
+      type: "literal",
+      value: "/",
+      source: "endRange"
+    },
+    {
+      type: "year",
+      value: "2020",
+      source: "endRange"
+    }
+  ]
+);
+assert.deepEqual(
+  at.formatRangeToParts(
+    date1.withCalendar(atCalendar).toPlainYearMonth(),
+    date2.withCalendar(atCalendar).toPlainYearMonth()
+  ),
+  [
+    {
+      type: "month",
+      value: "11",
+      source: "startRange"
+    },
+    {
+      type: "literal",
+      value: deMonthYearSeparator,
+      source: "startRange"
+    },
+    {
+      type: "year",
+      value: "1976",
+      source: "startRange"
+    },
+    {
+      type: "literal",
+      value: deDateRangeSeparator,
+      source: "shared"
+    },
+    {
+      type: "month",
+      value: "02",
+      source: "endRange"
+    },
+    {
+      type: "literal",
+      value: deMonthYearSeparator,
+      source: "endRange"
+    },
+    {
+      type: "year",
+      value: "2020",
+      source: "endRange"
+    }
+  ]
+);
+// should work for MonthDay
+var date1 = Temporal.PlainDate.from(t1);
+var date2 = Temporal.PlainDate.from(t2);
+assert.deepEqual(
+  us.formatRangeToParts(
+    date2.withCalendar(usCalendar).toPlainMonthDay(),
+    date1.withCalendar(usCalendar).toPlainMonthDay()
+  ),
+  [
+    {
+      type: "month",
+      value: "2",
+      source: "startRange"
+    },
+    {
+      type: "literal",
+      value: "/",
+      source: "startRange"
+    },
+    {
+      type: "day",
+      value: "20",
+      source: "startRange"
+    },
+    {
+      type: "literal",
+      value: usDateRangeSeparator,
+      source: "shared"
+    },
+    {
+      type: "month",
+      value: "11",
+      source: "endRange"
+    },
+    {
+      type: "literal",
+      value: "/",
+      source: "endRange"
+    },
+    {
+      type: "day",
+      value: "18",
+      source: "endRange"
+    }
+  ]
+);
+assert.deepEqual(
+  at.formatRangeToParts(
+    date2.withCalendar(atCalendar).toPlainMonthDay(),
+    date1.withCalendar(atCalendar).toPlainMonthDay()
+  ),
+  [
+    {
+      type: "day",
+      value: "20",
+      source: "startRange"
+    },
+    {
+      type: "literal",
+      value: ".",
+      source: "startRange"
+    },
+    {
+      type: "month",
+      value: "02",
+      source: "startRange"
+    },
+    {
+      type: "literal",
+      value: deMonthDayRangeSeparator,
+      source: "shared"
+    },
+    {
+      type: "day",
+      value: "18",
+      source: "endRange"
+    },
+    {
+      type: "literal",
+      value: ".",
+      source: "endRange"
+    },
+    {
+      type: "month",
+      value: "11",
+      source: "endRange"
+    },
+    {
+      type: "literal",
+      value: ".",
+      source: "shared"
+    }
+  ]
+);
+// should not break legacy Date
+assert.deepEqual(us.formatRangeToParts(start, end), [
+  {
+    type: "month",
+    value: "12",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "startRange"
+  },
+  {
+    type: "day",
+    value: "29",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "startRange"
+  },
+  {
+    type: "year",
+    value: "1922",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: usDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "month",
+    value: "12",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "endRange"
+  },
+  {
+    type: "day",
+    value: "25",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: "/",
+    source: "endRange"
+  },
+  {
+    type: "year",
+    value: "1991",
+    source: "endRange"
+  }
+]);
+assert.deepEqual(at.formatRangeToParts(start, end), [
+  {
+    type: "day",
+    value: "30",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "startRange"
+  },
+  {
+    type: "month",
+    value: "12",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "startRange"
+  },
+  {
+    type: "year",
+    value: "1922",
+    source: "startRange"
+  },
+  {
+    type: "literal",
+    value: deDateRangeSeparator,
+    source: "shared"
+  },
+  {
+    type: "day",
+    value: "26",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "endRange"
+  },
+  {
+    type: "month",
+    value: "12",
+    source: "endRange"
+  },
+  {
+    type: "literal",
+    value: ".",
+    source: "endRange"
+  },
+  {
+    type: "year",
+    value: "1991",
+    source: "endRange"
+  }
+]);
+// should throw a TypeError when called with dissimilar types
+assert.throws(TypeError, () => at.formatRangeToParts(Temporal.Instant.from(t1), Temporal.PlainDateTime.from(t2)));
+// should throw a RangeError when called with different calendars
+assert.throws(RangeError, () =>
+  at.formatRangeToParts(Temporal.PlainDateTime.from(t1), Temporal.PlainDateTime.from(t2).withCalendar("japanese"))
+);
+assert.throws(RangeError, () =>
+  at.formatRangeToParts(Temporal.PlainDate.from(t1), Temporal.PlainDate.from(t2).withCalendar("japanese"))
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/date-toLocaleString.js b/js/src/tests/test262/staging/Intl402/Temporal/old/date-toLocaleString.js
new file mode 100644
index 0000000000..973705f4ac
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/date-toLocaleString.js
@@ -0,0 +1,36 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: date.toLocaleString()
+features: [Temporal]
+---*/
+
+function maybeGetWeekdayOnlyFormat() {
+  const fmt = new Intl.DateTimeFormat('en', { weekday: 'long', timeZone: 'Europe/Vienna' });
+  if (
+    ['era', 'year', 'month', 'day', 'hour', 'minute', 'second', 'timeZoneName'].some(
+      (prop) => prop in fmt.resolvedOptions()
+    )
+  ) {
+   //no weekday-only format available 
+    return null;
+  }
+  return fmt;
+}
+
+var date = Temporal.PlainDate.from("1976-11-18T15:23:30");
+assert.sameValue(`${ date.toLocaleString("en-US", { timeZone: "America/New_York" }) }`, "11/18/1976");
+assert.sameValue(`${ date.toLocaleString("de-AT", { timeZone: "Europe/Vienna" }) }`, "18.11.1976");
+var fmt = maybeGetWeekdayOnlyFormat();
+if (fmt) assert.sameValue(fmt.format(date), "Thursday");
+
+// should ignore units not in the data type
+assert.sameValue(date.toLocaleString("en-US", { timeZoneName: "long" }), "11/18/1976");
+assert.sameValue(date.toLocaleString("en-US", { hour: "numeric" }), "11/18/1976");
+assert.sameValue(date.toLocaleString("en-US", { minute: "numeric" }), "11/18/1976");
+assert.sameValue(date.toLocaleString("en-US", { second: "numeric" }), "11/18/1976");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/datetime-toLocaleString.js b/js/src/tests/test262/staging/Intl402/Temporal/old/datetime-toLocaleString.js
new file mode 100644
index 0000000000..3cdced3faa
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/datetime-toLocaleString.js
@@ -0,0 +1,54 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: datetime.toLocaleString()
+features: [Temporal]
+---*/
+
+// Tolerate implementation variance by expecting consistency without being prescriptive.
+// TODO: can we change tests to be less reliant on CLDR formats while still testing that
+// Temporal and Intl are behaving as expected?
+const usDayPeriodSpace =
+  new Intl.DateTimeFormat("en-US", { timeStyle: "short" })
+    .formatToParts(0)
+    .find((part, i, parts) => part.type === "literal" && parts[i + 1].type === "dayPeriod")?.value || "";
+
+function maybeGetWeekdayOnlyFormat() {
+  const fmt = new Intl.DateTimeFormat("en-US", { weekday: "long", timeZone: "Europe/Vienna" });
+  if (
+    ["era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"].some(
+      (prop) => prop in fmt.resolvedOptions()
+    )
+  ) {
+    // no weekday-only format available
+    return null;
+  }
+  return fmt;
+}
+
+var datetime = Temporal.PlainDateTime.from("1976-11-18T15:23:30");
+assert.sameValue(
+  `${datetime.toLocaleString("en-US", { timeZone: "America/New_York" })}`,
+  `11/18/1976, 3:23:30${usDayPeriodSpace}PM`
+);
+assert.sameValue(`${datetime.toLocaleString("de-AT", { timeZone: "Europe/Vienna" })}`, "18.11.1976, 15:23:30");
+var fmt = maybeGetWeekdayOnlyFormat();
+if (fmt) assert.sameValue(fmt.format(datetime), "Thursday");
+
+// should ignore units not in the data type
+assert.sameValue(
+  datetime.toLocaleString("en-US", { timeZoneName: "long" }),
+  `11/18/1976, 3:23:30${usDayPeriodSpace}PM`
+);
+
+// should use compatible disambiguation option
+var dstStart = new Temporal.PlainDateTime(2020, 3, 8, 2, 30);
+assert.sameValue(
+  `${dstStart.toLocaleString("en-US", { timeZone: "America/Los_Angeles" })}`,
+  `3/8/2020, 3:30:00${usDayPeriodSpace}AM`
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/duration-arithmetic-dst.js b/js/src/tests/test262/staging/Intl402/Temporal/old/duration-arithmetic-dst.js
new file mode 100644
index 0000000000..08e9c8b428
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/duration-arithmetic-dst.js
@@ -0,0 +1,76 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: >
+  Various DST arithmetic tests that it's impractical to do without a time zone
+  database in the implementation
+features: [Temporal]
+---*/
+
+// Tests for arithmetic that start inside a repeated hour, and end in a skipped
+// hour. We have TemporalHelpers.springForwardFallBackTimeZone which is
+// sufficient to test this for Temporal.Duration.prototype.add, and
+// Temporal.Duration.prototype.round, but it's impractical to replicate all the
+// TZDB data for testing it with other methods such as subtract() where we need
+// to calculate to the _next_ transition
+
+var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]");
+var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]");
+var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]");
+
+// subtract()
+
+var oneDay = new Temporal.Duration(0, 0, 0, 1);
+assert.sameValue(`${ Temporal.Duration.from({
+  days: 127,
+  hours: 1
+}).subtract(oneDay, { relativeTo: inRepeatedHour }) }`, "P126DT1H");
+var hours24 = new Temporal.Duration(0, 0, 0, 0, 24);
+assert.sameValue(`${ Temporal.Duration.from({
+  days: 127,
+  hours: 1
+}).subtract(hours24, { relativeTo: inRepeatedHour }) }`, "P126D");
+
+// total()
+var totalDays = Temporal.Duration.from({
+  days: 126,
+  hours: 1
+}).total({
+  unit: "days",
+  relativeTo: inRepeatedHour
+});
+assert(Math.abs(totalDays - (126 + 1 / 23)) < Number.EPSILON);
+assert.sameValue(Temporal.Duration.from({
+  days: 126,
+  hours: 1
+}).total({
+  unit: "hours",
+  relativeTo: inRepeatedHour
+}), 3026);
+
+// Tests for casting relativeTo to ZonedDateTime when possible:
+// Without a TZDB, it's not possible to get a ZonedDateTime with DST from a
+// string.
+
+assert.sameValue(
+  `${ oneDay.add(hours24, { relativeTo: "2019-11-02T00:00[America/Vancouver]" }) }`,
+  "P1DT24H"
+);
+var hours25 = new Temporal.Duration(0, 0, 0, 0, 25);
+assert.sameValue(`${ hours25.round({
+  largestUnit: "days",
+  relativeTo: "2019-11-03T00:00[America/Vancouver]"
+}) }`, "P1D");
+assert.sameValue(
+  `${ oneDay.subtract(hours24, { relativeTo: "2019-11-03T00:00[America/Vancouver]" }) }`,
+  "PT1H"
+);
+assert.sameValue(oneDay.total({
+  unit: "hours",
+  relativeTo: "2019-11-03T00:00[America/Vancouver]"
+}), 25);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/hebrew-leap-months.js b/js/src/tests/test262/staging/Intl402/Temporal/old/hebrew-leap-months.js
new file mode 100644
index 0000000000..bdd410c4cf
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/hebrew-leap-months.js
@@ -0,0 +1,63 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: Hebrew leap months
+features: [Temporal]
+---*/
+
+// Valid leap month: Adar I 5779
+var date = Temporal.PlainDate.from({
+  year: 5779,
+  month: 6,
+  day: 1,
+  calendar: "hebrew"
+});
+assert.sameValue(date.month, 6);
+assert.sameValue(date.monthCode, "M05L");
+assert.sameValue(date.day, 1);
+date = Temporal.PlainDate.from({
+  year: 5779,
+  monthCode: "M05L",
+  day: 1,
+  calendar: "hebrew"
+});
+assert.sameValue(date.month, 6);
+assert.sameValue(date.monthCode, "M05L");
+assert.sameValue(date.day, 1);
+
+// Creating dates in later months in a leap year
+var date = Temporal.PlainDate.from({
+  year: 5779,
+  month: 7,
+  day: 1,
+  calendar: "hebrew"
+});
+assert.sameValue(date.month, 7);
+assert.sameValue(date.monthCode, "M06");
+assert.sameValue(date.day, 1);
+date = Temporal.PlainDate.from({
+  year: 5779,
+  monthCode: "M06",
+  day: 1,
+  calendar: "hebrew"
+});
+assert.sameValue(date.month, 7);
+assert.sameValue(date.monthCode, "M06");
+assert.sameValue(date.day, 1);
+
+// Invalid leap months: e.g. M02L
+for (var i = 1; i <= 12; i++) {
+  if (i === 5)
+    continue;
+  assert.throws(RangeError, () => Temporal.PlainDate.from({
+    year: 5779,
+    monthCode: `M${ i.toString().padStart(2, "0") }L`,
+    day: 1,
+    calendar: "hebrew"
+  }));
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/indian-calendar.js b/js/src/tests/test262/staging/Intl402/Temporal/old/indian-calendar.js
new file mode 100644
index 0000000000..1e82b4bc3f
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/indian-calendar.js
@@ -0,0 +1,39 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: Indian calendar
+features: [Temporal]
+---*/
+
+
+// throws in Node 12 & 14 before 1 CE
+var vulnerableToBceBug = new Date("0000-01-01T00:00Z").toLocaleDateString("en-US-u-ca-indian", { timeZone: "UTC" }) !== "10/11/-79 Saka";
+if (vulnerableToBceBug) {
+  assert.throws(RangeError, () => Temporal.PlainDate.from("0000-01-01").withCalendar("indian").day);
+}
+
+// handles leap days
+var leapYearFirstDay = Temporal.PlainDate.from("2004-03-21[u-ca=indian]");
+assert.sameValue(leapYearFirstDay.year, 2004 - 78);
+assert.sameValue(leapYearFirstDay.month, 1);
+assert.sameValue(leapYearFirstDay.day, 1);
+var leapYearLastDay = leapYearFirstDay.with({ day: 31 });
+assert.sameValue(leapYearLastDay.year, 2004 - 78);
+assert.sameValue(leapYearLastDay.month, 1);
+assert.sameValue(leapYearLastDay.day, 31);
+
+// handles non-leap years
+var nonLeapYearFirstDay = Temporal.PlainDate.from("2005-03-22[u-ca=indian]");
+assert.sameValue(nonLeapYearFirstDay.year, 2005 - 78);
+assert.sameValue(nonLeapYearFirstDay.month, 1);
+assert.sameValue(nonLeapYearFirstDay.day, 1);
+var leapYearLastDay = nonLeapYearFirstDay.with({ day: 31 });
+assert.sameValue(leapYearLastDay.year, 2005 - 78);
+assert.sameValue(leapYearLastDay.month, 1);
+assert.sameValue(leapYearLastDay.day, 30);
+assert.throws(RangeError, () => nonLeapYearFirstDay.with({ day: 31 }, { overflow: "reject" }));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/instant-toLocaleString.js b/js/src/tests/test262/staging/Intl402/Temporal/old/instant-toLocaleString.js
new file mode 100644
index 0000000000..5854d0dcdf
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/instant-toLocaleString.js
@@ -0,0 +1,48 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: Instant.toLocaleString()
+features: [Temporal]
+---*/
+
+// Tolerate implementation variance by expecting consistency without being prescriptive.
+// TODO: can we change tests to be less reliant on CLDR formats while still testing that
+// Temporal and Intl are behaving as expected?
+const usDayPeriodSpace =
+  new Intl.DateTimeFormat("en-US", { timeStyle: "short" })
+    .formatToParts(0)
+    .find((part, i, parts) => part.type === "literal" && parts[i + 1].type === "dayPeriod")?.value || "";
+
+function maybeGetWeekdayOnlyFormat() {
+  const fmt = new Intl.DateTimeFormat("en-US", { weekday: "long", timeZone: "Europe/Vienna" });
+  if (
+    ["era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"].some(
+      (prop) => prop in fmt.resolvedOptions()
+    )
+  ) {
+    // no weekday-only format available
+    return null;
+  }
+  return fmt;
+}
+
+var instant = Temporal.Instant.from("1976-11-18T14:23:30Z");
+assert.sameValue(
+  `${instant.toLocaleString("en-US", { timeZone: "America/New_York" })}`,
+  `11/18/1976, 9:23:30${usDayPeriodSpace}AM`
+);
+assert.sameValue(`${instant.toLocaleString("de-AT", { timeZone: "Europe/Vienna" })}`, "18.11.1976, 15:23:30");
+var fmt = maybeGetWeekdayOnlyFormat();
+if (fmt) assert.sameValue(fmt.format(instant), "Thursday");
+
+// outputs timeZoneName if requested
+var str = instant.toLocaleString("en-US", {
+  timeZone: "America/New_York",
+  timeZoneName: "short"
+});
+assert(str.includes("EST"));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/islamic-calendars.js b/js/src/tests/test262/staging/Intl402/Temporal/old/islamic-calendars.js
new file mode 100644
index 0000000000..c0726b0cae
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/islamic-calendars.js
@@ -0,0 +1,94 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: Islamic calendars (note there are 6 variants)
+features: [Temporal]
+---*/
+
+// Test data obtained from ICU
+
+const tests = [
+  {
+    calendar: "islamic",
+    inLeapYear: false,
+    daysInYear: 354,
+    daysInMonth12: 29,
+    isoYear: 2023,
+    isoMonth: 7,
+    isoDay: 18
+  },
+  {
+    calendar: "islamic-umalqura",
+    inLeapYear: false,
+    daysInYear: 354,
+    daysInMonth12: 30,
+    isoYear: 2023,
+    isoMonth: 7,
+    isoDay: 19
+  },
+  {
+    calendar: "islamic-civil",
+    inLeapYear: true,
+    daysInYear: 355,
+    daysInMonth12: 30,
+    isoYear: 2023,
+    isoMonth: 7,
+    isoDay: 19
+  },
+  {
+    calendar: "islamicc", // deprecated version of islamic-civil
+    inLeapYear: true,
+    daysInYear: 355,
+    daysInMonth12: 30,
+    isoYear: 2023,
+    isoMonth: 7,
+    isoDay: 19
+  },
+  {
+    calendar: "islamic-rgsa",
+    inLeapYear: false,
+    daysInYear: 354,
+    daysInMonth12: 29,
+    isoYear: 2023,
+    isoMonth: 7,
+    isoDay: 18
+  },
+  {
+    calendar: "islamic-tbla",
+    inLeapYear: true,
+    daysInYear: 355,
+    daysInMonth12: 30,
+    isoYear: 2023,
+    isoMonth: 7,
+    isoDay: 18
+  }
+];
+
+for (const test of tests) {
+  const { calendar, inLeapYear, daysInYear, daysInMonth12, isoYear, isoMonth, isoDay } = test;
+  const year = 1445;
+  const date = Temporal.PlainDate.from({ year, month: 1, day: 1, calendar });
+  const isoFields = date.getISOFields();
+  assert.sameValue(date.calendarId, calendar);
+  assert.sameValue(date.year, year);
+  assert.sameValue(date.month, 1);
+  assert.sameValue(date.monthCode, "M01");
+  assert.sameValue(date.day, 1);
+  assert.sameValue(date.inLeapYear, inLeapYear);
+  assert.sameValue(date.daysInYear, daysInYear);
+  assert.sameValue(date.monthsInYear, 12);
+  assert.sameValue(date.dayOfYear, 1);
+  const startOfNextYear = date.with({ year: year + 1 });
+  const lastDayOfThisYear = startOfNextYear.subtract({ days: 1 });
+  assert.sameValue(lastDayOfThisYear.dayOfYear, daysInYear);
+  const dateMonth12 = date.with({ month: 12 });
+  assert.sameValue(dateMonth12.daysInMonth, daysInMonth12);
+  assert.sameValue(isoYear, isoFields.isoYear);
+  assert.sameValue(isoMonth, isoFields.isoMonth);
+  assert.sameValue(isoDay, isoFields.isoDay);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/japanese-era.js b/js/src/tests/test262/staging/Intl402/Temporal/old/japanese-era.js
new file mode 100644
index 0000000000..47e16fbcb5
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/japanese-era.js
@@ -0,0 +1,140 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: Japanese eras
+features: [Temporal]
+---*/
+
+
+// Reiwa (2019-)
+var date = Temporal.PlainDate.from({
+  era: "reiwa",
+  eraYear: 2,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "2020-01-01[u-ca=japanese]");
+
+// Heisei (1989-2019)
+var date = Temporal.PlainDate.from({
+  era: "heisei",
+  eraYear: 2,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "1990-01-01[u-ca=japanese]");
+
+// Showa (1926-1989)
+var date = Temporal.PlainDate.from({
+  era: "showa",
+  eraYear: 2,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "1927-01-01[u-ca=japanese]");
+
+// Taisho (1912-1926)
+var date = Temporal.PlainDate.from({
+  era: "taisho",
+  eraYear: 2,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "1913-01-01[u-ca=japanese]");
+
+// Meiji (1868-1912)
+var date = Temporal.PlainDate.from({
+  era: "meiji",
+  eraYear: 2,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "1869-01-01[u-ca=japanese]");
+
+// Dates in same year before Japanese era starts will resolve to previous era
+var date = Temporal.PlainDate.from({
+  era: "reiwa",
+  eraYear: 1,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "2019-01-01[u-ca=japanese]");
+assert.sameValue(date.era, "heisei");
+assert.sameValue(date.eraYear, 31);
+
+date = Temporal.PlainDate.from({
+  era: "heisei",
+  eraYear: 1,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "1989-01-01[u-ca=japanese]");
+assert.sameValue(date.era, "showa");
+assert.sameValue(date.eraYear, 64);
+date = Temporal.PlainDate.from({
+  era: "showa",
+  eraYear: 1,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "1926-01-01[u-ca=japanese]");
+assert.sameValue(date.era, "taisho");
+assert.sameValue(date.eraYear, 15);
+
+date = Temporal.PlainDate.from({
+  era: "taisho",
+  eraYear: 1,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "1912-01-01[u-ca=japanese]");
+assert.sameValue(date.era, "meiji");
+assert.sameValue(date.eraYear, 45);
+
+date = Temporal.PlainDate.from({
+  era: "meiji",
+  eraYear: 1,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${ date }`, "1868-01-01[u-ca=japanese]");
+assert.sameValue(date.era, "ce");
+assert.sameValue(date.eraYear, 1868);
+
+// Verify that CE and BCE eras (before Meiji) are recognized
+date = Temporal.PlainDate.from({
+  era: "ce",
+  eraYear: 1000,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${date}`, "1000-01-01[u-ca=japanese]");
+assert.sameValue(date.era, "ce");
+assert.sameValue(date.eraYear, 1000);
+
+date = Temporal.PlainDate.from({
+  era: "bce",
+  eraYear: 1,
+  month: 1,
+  day: 1,
+  calendar: "japanese"
+});
+assert.sameValue(`${date}`, "0000-01-01[u-ca=japanese]");
+assert.sameValue(date.era, "bce");
+assert.sameValue(date.eraYear, 1);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/monthday-toLocaleString.js b/js/src/tests/test262/staging/Intl402/Temporal/old/monthday-toLocaleString.js
new file mode 100644
index 0000000000..a0452c1ab1
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/monthday-toLocaleString.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: monthday.toLocaleString()
+features: [Temporal]
+---*/
+
+var calendar = new Intl.DateTimeFormat("en-US").resolvedOptions().calendar;
+var monthday = Temporal.PlainMonthDay.from({
+  monthCode: "M11",
+  day: 18,
+  calendar
+});
+assert.sameValue(`${ monthday.toLocaleString("en-US", { timeZone: "America/New_York" }) }`, "11/18");
+assert.sameValue(`${ monthday.toLocaleString("de-AT", {
+  timeZone: "Europe/Vienna",
+  calendar
+}) }`, "18.11.");
+
+// should ignore units not in the data type
+assert.sameValue(monthday.toLocaleString("en-US", { timeZoneName: "long" }), "11/18");
+assert.sameValue(monthday.toLocaleString("en-US", { year: "numeric" }), "11/18");
+assert.sameValue(monthday.toLocaleString("en-US", { hour: "numeric" }), "11/18");
+assert.sameValue(monthday.toLocaleString("en-US", { minute: "numeric" }), "11/18");
+assert.sameValue(monthday.toLocaleString("en-US", { second: "numeric" }), "11/18");
+assert.sameValue(monthday.toLocaleString("en-US", { weekday: "long" }), "11/18");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/non-iso-calendars.js b/js/src/tests/test262/staging/Intl402/Temporal/old/non-iso-calendars.js
new file mode 100644
index 0000000000..a4f1a2908f
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/non-iso-calendars.js
@@ -0,0 +1,1380 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: Non-ISO Calendars
+features: [Temporal, Array.prototype.includes]
+---*/
+
+var testChineseData = new Date("2001-02-01T00:00Z").toLocaleString("en-US-u-ca-chinese", {
+  day: "numeric",
+  month: "numeric",
+  year: "numeric",
+  era: "short",
+  timeZone: "UTC"
+});
+var hasOutdatedChineseIcuData = !testChineseData.endsWith("2001");
+
+// verify that Intl.DateTimeFormat.formatToParts output matches snapshot data
+var getLocalizedDates = isoString => {
+  var calendars = [
+    "iso8601",
+    "buddhist",
+    "chinese",
+    "coptic",
+    "dangi",
+    "ethioaa",
+    "ethiopic",
+    "gregory",
+    "hebrew",
+    "indian",
+    "islamic",
+    "islamic-umalqura",
+    "islamic-tbla",
+    "islamic-civil",
+    "islamic-rgsa",
+    "islamicc",
+    "japanese",
+    "persian",
+    "roc"
+  ];
+  var date = new Date(isoString);
+  return calendars.map(id => `${ id }: ${ date.toLocaleDateString(`en-US-u-ca-${ id }`, { timeZone: "UTC" }) }`).join("\n");
+};
+var year2000Content = getLocalizedDates("2000-01-01T00:00Z");
+var year1Content = getLocalizedDates("0001-01-01T00:00Z");
+var year2000Snapshot = "iso8601: 1/1/2000\n" + "buddhist: 1/1/2543 BE\n" + "chinese: 11/25/1999\n" + "coptic: 4/22/1716 ERA1\n" + "dangi: 11/25/1999\n" + "ethioaa: 4/22/7492 ERA0\n" + "ethiopic: 4/22/1992 ERA1\n" + "gregory: 1/1/2000\n" + "hebrew: 23 Tevet 5760\n" + "indian: 10/11/1921 Saka\n" + "islamic: 9/25/1420 AH\n" + "islamic-umalqura: 9/24/1420 AH\n" + "islamic-tbla: 9/25/1420 AH\n" + "islamic-civil: 9/24/1420 AH\n" + "islamic-rgsa: 9/25/1420 AH\n" + "islamicc: 9/24/1420 AH\n" + "japanese: 1/1/12 H\n" + "persian: 10/11/1378 AP\n" + "roc: 1/1/89 Minguo";
+assert.sameValue(year2000Content, year2000Snapshot);
+
+// Several calendars based on the Gregorian calendar use Julian dates (not
+// proleptic Gregorian dates) before the Gregorian switchover in Oct 1582. See
+// https://bugs.chromium.org/p/chromium/issues/detail?id=1173158. The code below
+// allows these tests to pass regardless of the bug, while still remaining
+// sensitive to other bugs that may crop up.
+const yearOneMonthDay = new Map(
+  ["iso8601", "gregory", "roc", "buddhist", "japanese"].map(calendar => {
+    hasGregorianSwitchoverBug = new Date("+001001-01-01T00:00Z")
+      .toLocaleDateString(`en-US-u-ca-${calendar}`, { timeZone: "UTC" })
+      .startsWith("12");
+    return [calendar, hasGregorianSwitchoverBug ? "1/3" : "1/1"]
+  }));
+var year1Snapshot = 
+  `iso8601: ${yearOneMonthDay.get("iso8601")}/1\n` + 
+  `buddhist: ${yearOneMonthDay.get("buddhist")}/544 BE\n` +
+  "chinese: 11/21/0\n" +
+  "coptic: 5/8/284 ERA0\n" +
+  "dangi: 11/21/0\n" +
+  "ethioaa: 5/8/5493 ERA0\n" +
+  "ethiopic: 5/8/5493 ERA0\n" +
+  `gregory: ${yearOneMonthDay.get("gregory")}/1\n` +
+  "hebrew: 18 Tevet 3761\n" +
+  "indian: 10/11/-78 Saka\n" +
+  "islamic: 5/20/-640 AH\n" +
+  "islamic-umalqura: 5/18/-640 AH\n" +
+  "islamic-tbla: 5/19/-640 AH\n" +
+  "islamic-civil: 5/18/-640 AH\n" +
+  "islamic-rgsa: 5/20/-640 AH\n" +
+  "islamicc: 5/18/-640 AH\n" +
+  `japanese: ${yearOneMonthDay.get("japanese")}/-643 Taika (645\u2013650)\n` +
+  "persian: 10/11/-621 AP\n" +
+  `roc: ${yearOneMonthDay.get("roc")}/1911 B.R.O.C.`;
+assert.sameValue(year1Content, year1Snapshot);
+var fromWithCases = {
+  iso8601: {
+    year2000: {
+      year: 2000,
+      month: 1,
+      day: 1
+    },
+    year1: {
+      year: 1,
+      month: 1,
+      day: 1
+    }
+  },
+  buddhist: {
+    year2000: {
+      year: 2543,
+      month: 1,
+      day: 1,
+      era: "be"
+    },
+    year1: RangeError
+  },
+  chinese: {
+    year2000: {
+      year: 1999,
+      month: 11,
+      day: 25
+    },
+    year1: {
+      year: 0,
+      month: 12,
+      monthCode: "M11",
+      day: 21
+    }
+  },
+  coptic: {
+    year2000: {
+      year: 1716,
+      month: 4,
+      day: 22,
+      era: "era1"
+    },
+    year1: {
+      year: -283,
+      eraYear: 284,
+      month: 5,
+      day: 8,
+      era: "era0"
+    }
+  },
+  dangi: {
+    year2000: {
+      year: 1999,
+      month: 11,
+      day: 25
+    },
+    year1: {
+      year: 0,
+      month: 12,
+      monthCode: "M11",
+      day: 21
+    }
+  },
+  ethioaa: {
+    year2000: {
+      year: 7492,
+      month: 4,
+      day: 22,
+      era: "era0"
+    },
+    year1: {
+      year: 5493,
+      month: 5,
+      day: 8,
+      era: "era0"
+    }
+  },
+  ethiopic: {
+    year2000: {
+      eraYear: 1992,
+      year: 7492,
+      month: 4,
+      day: 22,
+      era: "era1"
+    },
+    year1: {
+      year: 5493,
+      month: 5,
+      day: 8,
+      era: "era0"
+    }
+  },
+  gregory: {
+    year2000: {
+      year: 2000,
+      month: 1,
+      day: 1,
+      era: "ce"
+    },
+    year1: {
+      year: 1,
+      month: 1,
+      day: 1,
+      era: "ce"
+    }
+  },
+  hebrew: {
+    year2000: {
+      year: 5760,
+      month: 4,
+      day: 23
+    },
+    year1: {
+      year: 3761,
+      month: 4,
+      day: 18
+    }
+  },
+  indian: {
+    year2000: {
+      year: 1921,
+      month: 10,
+      day: 11,
+      era: "saka"
+    },
+    year1: {
+      year: -78,
+      month: 10,
+      day: 11,
+      era: "saka"
+    }
+  },
+  islamic: {
+    year2000: {
+      year: 1420,
+      month: 9,
+      day: 25,
+      era: "ah"
+    },
+    year1: {
+      year: -640,
+      month: 5,
+      day: 20,
+      era: "ah"
+    }
+  },
+  "islamic-umalqura": {
+    year2000: {
+      year: 1420,
+      month: 9,
+      day: 24,
+      era: "ah"
+    },
+    year1: {
+      year: -640,
+      month: 5,
+      day: 18,
+      era: "ah"
+    }
+  },
+  "islamic-tbla": {
+    year2000: {
+      year: 1420,
+      month: 9,
+      day: 25,
+      era: "ah"
+    },
+    year1: {
+      year: -640,
+      month: 5,
+      day: 19,
+      era: "ah"
+    }
+  },
+  "islamic-civil": {
+    year2000: {
+      year: 1420,
+      month: 9,
+      day: 24,
+      era: "ah"
+    },
+    year1: {
+      year: -640,
+      month: 5,
+      day: 18,
+      era: "ah"
+    }
+  },
+  "islamic-rgsa": {
+    year2000: {
+      year: 1420,
+      month: 9,
+      day: 25,
+      era: "ah"
+    },
+    year1: {
+      year: -640,
+      month: 5,
+      day: 20,
+      era: "ah"
+    }
+  },
+  islamicc: {
+    year2000: {
+      year: 1420,
+      month: 9,
+      day: 24,
+      era: "ah"
+    },
+    year1: {
+      year: -640,
+      month: 5,
+      day: 18,
+      era: "ah"
+    }
+  },
+  japanese: {
+    year2000: {
+      year: 2000,
+      eraYear: 12,
+      month: 1,
+      day: 1,
+      era: "heisei"
+    },
+    year1: RangeError
+  },
+  persian: {
+    year2000: {
+      year: 1378,
+      month: 10,
+      day: 11,
+      era: "ap"
+    },
+    year1: {
+      year: -621,
+      month: 10,
+      day: 11,
+      era: "ap"
+    }
+  },
+  roc: {
+    year2000: {
+      year: 89,
+      month: 1,
+      day: 1,
+      era: "minguo"
+    },
+    year1: RangeError
+  }
+};
+var logPerf = false;
+var totalNow = 0;
+for (var [id, tests] of Object.entries(fromWithCases)) {
+  var dates = {
+    year2000: Temporal.PlainDate.from("2000-01-01"),
+    year1: Temporal.PlainDate.from("0001-01-01")
+  };
+  for (var [name, date] of Object.entries(dates)) {
+    var values = tests[name];
+    var errorExpected = values === RangeError;
+    if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
+      var now = globalThis.performance ? globalThis.performance.now() : Date.now();
+      if (errorExpected) {
+        assert.throws(RangeError, () => {
+          var inCal = date.withCalendar(id);
+          Temporal.PlainDate.from({
+            calendar: id,
+            year: inCal.year,
+            day: inCal.day,
+            monthCode: inCal.monthCode
+          });
+        });
+      }
+      var inCal = date.withCalendar(id);
+      assert.sameValue(`${ name } ${ id } day: ${ inCal.day }`, `${ name } ${ id } day: ${ values.day }`);
+      if (values.eraYear === undefined && values.era !== undefined)
+        values.eraYear = values.year;
+      assert.sameValue(`${ name } ${ id } eraYear: ${ inCal.eraYear }`, `${ name } ${ id } eraYear: ${ values.eraYear }`);
+      assert.sameValue(`${ name } ${ id } era: ${ inCal.era }`, `${ name } ${ id } era: ${ values.era }`);
+      assert.sameValue(`${ name } ${ id } year: ${ inCal.year }`, `${ name } ${ id } year: ${ values.year }`);
+      assert.sameValue(`${ name } ${ id } month: ${ inCal.month }`, `${ name } ${ id } month: ${ values.month }`);
+      if (values.monthCode === undefined)
+        values.monthCode = `M${ values.month.toString().padStart(2, "0") }`;
+      assert.sameValue(`${ name } ${ id } monthCode: ${ inCal.monthCode }`, `${ name } ${ id } monthCode: ${ values.monthCode }`);
+      if (values.era) {
+        var dateRoundtrip1 = Temporal.PlainDate.from({
+          calendar: id,
+          eraYear: values.eraYear,
+          era: values.era,
+          day: values.day,
+          monthCode: values.monthCode
+        });
+        assert.sameValue(dateRoundtrip1.toString(), inCal.toString());
+        assert.throws(RangeError, () => Temporal.PlainDate.from({
+          calendar: id,
+          eraYear: values.eraYear,
+          era: values.era,
+          day: values.day,
+          monthCode: values.monthCode,
+          year: values.year + 1
+        }));
+      }
+      var dateRoundtrip2 = Temporal.PlainDate.from({
+        calendar: id,
+        year: values.year,
+        day: values.day,
+        monthCode: values.monthCode
+      });
+      assert.sameValue(dateRoundtrip2.toString(), inCal.toString());
+      var dateRoundtrip3 = Temporal.PlainDate.from({
+        calendar: id,
+        year: values.year,
+        day: values.day,
+        month: values.month
+      });
+      assert.sameValue(dateRoundtrip3.toString(), inCal.toString());
+      var dateRoundtrip4 = Temporal.PlainDate.from({
+        calendar: id,
+        year: values.year,
+        day: values.day,
+        monthCode: values.monthCode
+      });
+      assert.sameValue(dateRoundtrip4.toString(), inCal.toString());
+      assert.throws(RangeError, () => Temporal.PlainDate.from({
+        calendar: id,
+        day: values.day,
+        month: values.month === 1 ? 2 : values.month - 1,
+        monthCode: values.monthCode,
+        year: values.year
+      }));
+      var ms = (globalThis.performance ? globalThis.performance.now() : Date.now()) - now;
+      totalNow += ms;
+      if (logPerf)
+        console.log(`from: ${ id } ${ name }: ${ ms.toFixed(2) }ms, total: ${ totalNow.toFixed(2) }ms`);
+    };
+    if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
+      var now = globalThis.performance ? globalThis.performance.now() : Date.now();
+      var inCal = date.withCalendar(id);
+      if (errorExpected) {
+        assert.throws(RangeError, () => inCal.with({ day: 1 }).year);
+      }
+      var afterWithDay = inCal.with({ day: 1 });
+      var t = "(after setting day)";
+      assert.sameValue(`${ t } year: ${ afterWithDay.year }`, `${ t } year: ${ inCal.year }`);
+      assert.sameValue(`${ t } month: ${ afterWithDay.month }`, `${ t } month: ${ inCal.month }`);
+      assert.sameValue(`${ t } day: ${ afterWithDay.day }`, `${ t } day: 1`);
+      var afterWithMonth = afterWithDay.with({ month: 1 });
+      t = "(after setting month)";
+      assert.sameValue(`${ t } year: ${ afterWithMonth.year }`, `${ t } year: ${ inCal.year }`);
+      assert.sameValue(`${ t } month: ${ afterWithMonth.month }`, `${ t } month: 1`);
+      assert.sameValue(`${ t } day: ${ afterWithMonth.day }`, `${ t } day: 1`);
+      var afterWithYear = afterWithMonth.with({ year: 2220 });
+      t = "(after setting year)";
+      assert.sameValue(`${ t } year: ${ afterWithYear.year }`, `${ t } year: 2220`);
+      assert.sameValue(`${ t } month: ${ afterWithYear.month }`, `${ t } month: 1`);
+      assert.sameValue(`${ t } day: ${ afterWithYear.day }`, `${ t } day: 1`);
+      var ms = (globalThis.performance ? globalThis.performance.now() : Date.now()) - now;
+      totalNow += ms;
+      if (logPerf)
+        console.log(`with: ${ id } ${ name }: ${ ms.toFixed(2) }ms, total: ${ totalNow.toFixed(2) }ms`);
+    };
+  }
+}
+var addDaysWeeksCases = {
+  iso8601: {
+    year: 2000,
+    month: 10,
+    day: 7,
+    monthCode: "M10",
+    eraYear: undefined,
+    era: undefined
+  },
+  buddhist: RangeError,
+  chinese: {
+    year: 2000,
+    month: 10,
+    day: 16,
+    monthCode: "M10",
+    eraYear: undefined,
+    era: undefined
+  },
+  coptic: {
+    year: 2000,
+    month: 10,
+    day: 11,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "era1"
+  },
+  dangi: {
+    year: 2000,
+    month: 10,
+    day: 16,
+    monthCode: "M10",
+    eraYear: undefined,
+    era: undefined
+  },
+  ethioaa: {
+    year: 2000,
+    month: 10,
+    day: 11,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "era0"
+  },
+  ethiopic: {
+    year: 2000,
+    month: 10,
+    day: 11,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "era0"
+  },
+  gregory: {
+    year: 2000,
+    month: 10,
+    day: 7,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "ce"
+  },
+  hebrew: {
+    year: 2000,
+    month: 10,
+    day: 14,
+    monthCode: "M10",
+    eraYear: undefined,
+    era: undefined
+  },
+  indian: {
+    year: 2000,
+    month: 10,
+    day: 6,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "saka"
+  },
+  islamic: {
+    year: 2000,
+    month: 10,
+    day: 15,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "ah"
+  },
+  "islamic-umalqura": {
+    year: 2000,
+    month: 10,
+    day: 15,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "ah"
+  },
+  "islamic-tbla": {
+    year: 2000,
+    month: 10,
+    day: 15,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "ah"
+  },
+  "islamic-civil": {
+    year: 2000,
+    month: 10,
+    day: 15,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "ah"
+  },
+  "islamic-rgsa": {
+    year: 2000,
+    month: 10,
+    day: 15,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "ah"
+  },
+  islamicc: {
+    year: 2000,
+    month: 10,
+    day: 15,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "ah"
+  },
+  japanese: {
+    year: 2000,
+    month: 10,
+    day: 7,
+    monthCode: "M10",
+    eraYear: 12,
+    era: "heisei"
+  },
+  persian: {
+    year: 2000,
+    month: 10,
+    day: 5,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "ap"
+  },
+  roc: {
+    year: 2000,
+    month: 10,
+    day: 8,
+    monthCode: "M10",
+    eraYear: 2000,
+    era: "minguo"
+  }
+};
+const addMonthsCases = {
+  iso8601: { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: undefined, era: undefined },
+  // See https://bugs.chromium.org/p/chromium/issues/detail?id=1173158
+  buddhist: RangeError, // { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'be' },
+  chinese: { year: 2001, month: 6, day: 1, monthCode: 'M05', eraYear: undefined, era: undefined },
+  coptic: { year: 2001, month: 5, day: 1, monthCode: 'M05', eraYear: 2001, era: 'era1' },
+  dangi: { year: 2001, month: 6, day: 1, monthCode: 'M05', eraYear: undefined, era: undefined },
+  ethioaa: { year: 2001, month: 5, day: 1, monthCode: 'M05', eraYear: 2001, era: 'era0' },
+  ethiopic: { year: 2001, month: 5, day: 1, monthCode: 'M05', eraYear: 2001, era: 'era0' },
+  gregory: { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ce' },
+  hebrew: { year: 2001, month: 6, day: 1, monthCode: 'M05L', eraYear: undefined, era: undefined },
+  indian: { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'saka' },
+  islamic: { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ah' },
+  'islamic-umalqura': { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ah' },
+  'islamic-tbla': { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ah' },
+  'islamic-civil': { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ah' },
+  'islamic-rgsa': { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ah' },
+  islamicc: { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ah' },
+  japanese: { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 13, era: 'heisei' },
+  persian: { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'ap' },
+  roc: { year: 2001, month: 6, day: 1, monthCode: 'M06', eraYear: 2001, era: 'minguo' }
+};
+var i = 0;
+const addYearsMonthsDaysCases = Object.entries(addMonthsCases).reduce((obj, entry) => {
+  obj[entry[0]] = entry[1] === RangeError ? RangeError : { ...entry[1], day: 18 };
+  return obj;
+}, {});
+var tests = {
+  days: {
+    duration: { days: 280 },
+    results: addDaysWeeksCases,
+    startDate: {
+      year: 2000,
+      month: 1,
+      day: 1
+    }
+  },
+  weeks: {
+    duration: { weeks: 40 },
+    results: addDaysWeeksCases,
+    startDate: {
+      year: 2000,
+      month: 1,
+      day: 1
+    }
+  },
+  months: {
+    duration: { months: 6 },
+    results: addMonthsCases,
+    startDate: {
+      year: 2000,
+      month: 12,
+      day: 1
+    }
+  },
+  years: {
+    duration: {
+      years: 3,
+      months: 6,
+      days: 17
+    },
+    results: addYearsMonthsDaysCases,
+    startDate: {
+      year: 1997,
+      monthCode: "M12",
+      day: 1
+    }
+  }
+};
+var calendars = Object.keys(addMonthsCases);
+for (var id of calendars) {
+  for (var [unit, {duration, results, startDate}] of Object.entries(tests)) {
+    var values = results[id];
+    duration = Temporal.Duration.from(duration);
+    if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
+      var now = globalThis.performance ? globalThis.performance.now() : Date.now();
+      if (values === RangeError) {
+        assert.throws(RangeError, () => Temporal.PlainDate.from({
+          ...startDate,
+          calendar: id
+        }));
+      }
+      var start = Temporal.PlainDate.from({
+        ...startDate,
+        calendar: id
+      });
+      var end = start.add(duration);
+      assert.sameValue(`add ${ unit } ${ id } day: ${ end.day }`, `add ${ unit } ${ id } day: ${ values.day }`);
+      assert.sameValue(`add ${ unit } ${ id } eraYear: ${ end.eraYear }`, `add ${ unit } ${ id } eraYear: ${ values.eraYear }`);
+      assert.sameValue(`add ${ unit } ${ id } era: ${ end.era }`, `add ${ unit } ${ id } era: ${ values.era }`);
+      assert.sameValue(`add ${ unit } ${ id } year: ${ end.year }`, `add ${ unit } ${ id } year: ${ values.year }`);
+      assert.sameValue(`add ${ unit } ${ id } month: ${ end.month }`, `add ${ unit } ${ id } month: ${ values.month }`);
+      assert.sameValue(`add ${ unit } ${ id } monthCode: ${ end.monthCode }`, `add ${ unit } ${ id } monthCode: ${ values.monthCode }`);
+      var calculatedStart = end.subtract(duration);
+      var isLunisolar = [
+        "chinese",
+        "dangi",
+        "hebrew"
+      ].includes(id);
+      var expectedCalculatedStart = isLunisolar && duration.years !== 0 && !end.monthCode.endsWith("L") ? start.subtract({ months: 1 }) : start;
+      assert.sameValue(`start ${ calculatedStart.toString() }`, `start ${ expectedCalculatedStart.toString() }`);
+      var diff = start.until(end, { largestUnit: unit });
+      assert.sameValue(`diff ${ unit } ${ id }: ${ diff }`, `diff ${ unit } ${ id }: ${ duration }`);
+      if (unit === "months") {
+        var startYesterday = start.subtract({ days: 1 });
+        var endYesterday = startYesterday.add(duration);
+        assert.sameValue(`add from end-of-month ${ unit } ${ id } day (initial): ${ endYesterday.day }`, `add from end-of-month ${ unit } ${ id } day (initial): ${ Math.min(startYesterday.day, endYesterday.daysInMonth) }`);
+        var endYesterdayNextDay = endYesterday.add({ days: 1 });
+        while (endYesterdayNextDay.day !== 1) {
+          endYesterdayNextDay = endYesterdayNextDay.add({ days: 1 });
+        }
+        assert.sameValue(`add from end-of-month ${ unit } ${ id } day: ${ endYesterdayNextDay.day }`, `add from end-of-month ${ unit } ${ id } day: ${ values.day }`);
+        assert.sameValue(`add from end-of-month ${ unit } ${ id } eraYear: ${ endYesterdayNextDay.eraYear }`, `add from end-of-month ${ unit } ${ id } eraYear: ${ values.eraYear }`);
+        assert.sameValue(`add from end-of-month ${ unit } ${ id } era: ${ endYesterdayNextDay.era }`, `add from end-of-month ${ unit } ${ id } era: ${ values.era }`);
+        assert.sameValue(`add from end-of-month ${ unit } ${ id } year: ${ endYesterdayNextDay.year }`, `add from end-of-month ${ unit } ${ id } year: ${ values.year }`);
+        assert.sameValue(`add from end-of-month ${ unit } ${ id } month: ${ endYesterdayNextDay.month }`, `add from end-of-month ${ unit } ${ id } month: ${ values.month }`);
+        assert.sameValue(`add from end-of-month ${ unit } ${ id } monthCode: ${ endYesterdayNextDay.monthCode }`, `add from end-of-month ${ unit } ${ id } monthCode: ${ values.monthCode }`);
+        var endReverse = endYesterdayNextDay.subtract({ days: 1 });
+        var startReverse = endReverse.subtract(duration);
+        assert.sameValue(`subtract from end-of-month ${ unit } ${ id } day (initial): ${ startReverse.day }`, `subtract from end-of-month ${ unit } ${ id } day (initial): ${ Math.min(endReverse.day, startReverse.daysInMonth) }`);
+        var startReverseNextDay = startReverse.add({ days: 1 });
+        while (startReverseNextDay.day !== 1) {
+          startReverseNextDay = startReverseNextDay.add({ days: 1 });
+        }
+        assert.sameValue(`subtract from end-of-month ${ unit } ${ id } day: ${ startReverseNextDay.day }`, `subtract from end-of-month ${ unit } ${ id } day: ${ start.day }`);
+        assert.sameValue(`subtract from end-of-month ${ unit } ${ id } eraYear: ${ startReverseNextDay.eraYear }`, `subtract from end-of-month ${ unit } ${ id } eraYear: ${ start.eraYear }`);
+        assert.sameValue(`subtract from end-of-month ${ unit } ${ id } era: ${ startReverseNextDay.era }`, `subtract from end-of-month ${ unit } ${ id } era: ${ start.era }`);
+        assert.sameValue(`subtract from end-of-month ${ unit } ${ id } year: ${ startReverseNextDay.year }`, `subtract from end-of-month ${ unit } ${ id } year: ${ start.year }`);
+        assert.sameValue(`subtract from end-of-month ${ unit } ${ id } month: ${ startReverseNextDay.month }`, `subtract from end-of-month ${ unit } ${ id } month: ${ start.month }`);
+        assert.sameValue(`subtract from end-of-month ${ unit } ${ id } monthCode: ${ startReverseNextDay.monthCode }`, `subtract from end-of-month ${ unit } ${ id } monthCode: ${ start.monthCode }`);
+      }
+      var ms = (globalThis.performance ? globalThis.performance.now() : Date.now()) - now;
+      totalNow += ms;
+      if (logPerf)
+        console.log(`${ id } add ${ duration }: ${ ms.toFixed(2) }ms, total: ${ totalNow.toFixed(2) }ms`);
+    };
+  }
+}
+var daysInMonthCases = {
+  iso8601: {
+    year: 2001,
+    leap: false,
+    days: [
+      31,
+      28,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      30,
+      31,
+      30,
+      31
+    ]
+  },
+  buddhist: {
+    year: 4001,
+    leap: false,
+    days: [
+      31,
+      28,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      30,
+      31,
+      30,
+      31
+    ]
+  },
+  chinese: {
+    year: 2001,
+    leap: "M04L",
+    days: [
+      30,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30
+    ]
+  },
+  coptic: {
+    year: 2001,
+    leap: false,
+    days: [
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      5
+    ]
+  },
+  dangi: {
+    year: 2001,
+    leap: "M04L",
+    days: [
+      30,
+      30,
+      30,
+      29,
+      29,
+      30,
+      29,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30
+    ]
+  },
+  ethioaa: {
+    year: 2001,
+    leap: false,
+    days: [
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      5
+    ]
+  },
+  ethiopic: {
+    year: 2001,
+    leap: false,
+    days: [
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      5
+    ]
+  },
+  gregory: {
+    year: 2001,
+    leap: false,
+    days: [
+      31,
+      28,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      30,
+      31,
+      30,
+      31
+    ]
+  },
+  hebrew: {
+    year: 2001,
+    leap: "M05L",
+    days: [
+      30,
+      30,
+      30,
+      29,
+      30,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29
+    ]
+  },
+  indian: {
+    year: 2001,
+    leap: false,
+    days: [
+      30,
+      31,
+      31,
+      31,
+      31,
+      31,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30
+    ]
+  },
+  islamic: {
+    year: 2001,
+    leap: false,
+    days: [
+      29,
+      30,
+      29,
+      29,
+      30,
+      29,
+      30,
+      30,
+      29,
+      30,
+      30,
+      29
+    ]
+  },
+  "islamic-umalqura": {
+    year: 2001,
+    leap: true,
+    days: [
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      30
+    ]
+  },
+  "islamic-tbla": {
+    year: 2001,
+    leap: true,
+    days: [
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      30
+    ]
+  },
+  "islamic-civil": {
+    year: 2001,
+    leap: true,
+    days: [
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      30
+    ]
+  },
+  "islamic-rgsa": {
+    year: 2001,
+    leap: false,
+    days: [
+      29,
+      30,
+      29,
+      29,
+      30,
+      29,
+      30,
+      30,
+      29,
+      30,
+      30,
+      29
+    ]
+  },
+  islamicc: {
+    year: 2001,
+    leap: true,
+    days: [
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      29,
+      30,
+      30
+    ]
+  },
+  japanese: {
+    year: 2001,
+    leap: false,
+    days: [
+      31,
+      28,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      30,
+      31,
+      30,
+      31
+    ]
+  },
+  persian: {
+    year: 2001,
+    leap: false,
+    days: [
+      31,
+      31,
+      31,
+      31,
+      31,
+      31,
+      30,
+      30,
+      30,
+      30,
+      30,
+      29
+    ]
+  },
+  roc: {
+    year: 2001,
+    leap: true,
+    days: [
+      31,
+      29,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      30,
+      31,
+      30,
+      31
+    ]
+  }
+};
+totalNow = 0;
+for (var id of calendars) {
+  var {year, leap, days} = daysInMonthCases[id];
+  var date = hasOutdatedChineseIcuData && (id === "chinese" || id === "dangi") ? undefined : Temporal.PlainDate.from({
+    year,
+    month: 1,
+    day: 1,
+    calendar: id
+  });
+  if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
+    if (typeof leap === "boolean") {
+      assert.sameValue(date.inLeapYear, leap);
+    } else {
+      assert.sameValue(date.inLeapYear, true);
+      var leapMonth = date.with({ monthCode: leap });
+      assert.sameValue(leapMonth.monthCode, leap);
+    }
+  };
+  if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
+    var now = globalThis.performance ? globalThis.performance.now() : Date.now();
+    var {monthsInYear} = date;
+    assert.sameValue(monthsInYear, days.length);
+    for (var i = monthsInYear, leapMonthIndex = undefined, monthStart = undefined; i >= 1; i--) {
+      monthStart = monthStart ? monthStart.add({ months: -1 }) : date.add({ months: monthsInYear - 1 });
+      var {month, monthCode, daysInMonth} = monthStart;
+      assert.sameValue(`${ id } month ${ i } (code ${ monthCode }) days: ${ daysInMonth }`, `${ id } month ${ i } (code ${ monthCode }) days: ${ days[i - 1] }`);
+      if (monthCode.endsWith("L")) {
+        assert.sameValue(date.with({ monthCode }).monthCode, monthCode);
+        leapMonthIndex = i;
+      } else {
+        if (leapMonthIndex && i === leapMonthIndex - 1) {
+          var inLeapMonth = monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` });
+          assert.sameValue(inLeapMonth.monthCode, `${ monthCode }L`);
+        } else {
+          assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }, { overflow: "reject" }));
+          if ([
+              "chinese",
+              "dangi"
+            ].includes(id)) {
+            if (i === 1 || i === 12 || i === 13) {
+              assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }));
+            } else {
+              var fakeL = monthStart.with({
+                monthCode: `M${ month.toString().padStart(2, "0") }L`,
+                day: 5
+              });
+              assert.sameValue(`fake leap month ${ fakeL.monthCode }`, `fake leap month M${ month.toString().padStart(2, "0") }`);
+              assert.sameValue(fakeL.day, fakeL.daysInMonth);
+            }
+          }
+        }
+        if (![
+            "chinese",
+            "dangi",
+            "hebrew"
+          ].includes(id)) {
+          assert.throws(RangeError, () => monthStart.with({ monthCode: `M${ month.toString().padStart(2, "0") }L` }));
+        }
+      }
+      assert.throws(RangeError, () => monthStart.with({ day: daysInMonth + 1 }, { overflow: "reject" }));
+      var oneDayPastMonthEnd = monthStart.with({ day: daysInMonth + 1 });
+      assert.sameValue(oneDayPastMonthEnd.day, daysInMonth);
+    }
+    var ms = (globalThis.performance ? globalThis.performance.now() : Date.now()) - now;
+    totalNow += ms;
+    if (logPerf)
+      console.log(`${ id } months check ${ id }: ${ ms.toFixed(2) }ms, total: ${ totalNow.toFixed(2) }ms`);
+  };
+}
+var monthDayCases = [
+  {
+    calendar: "iso8601",
+    isoReferenceYear: 1972,
+    year: 2004,
+    month: 2,
+    day: 29
+  },
+  {
+    calendar: "buddhist",
+    isoReferenceYear: 1972,
+    year: 2004,
+    month: 2,
+    day: 29
+  },
+  {
+    calendar: "chinese",
+    isoReferenceYear: 1963,
+    year: 2001,
+    month: 5,
+    monthCode: "M04L",
+    day: 15
+  },
+  {
+    calendar: "chinese",
+    isoReferenceYear: 1971,
+    year: 2000,
+    month: 6,
+    day: 30
+  },
+  {
+    calendar: "coptic",
+    isoReferenceYear: 1971,
+    year: 2006,
+    month: 13,
+    day: 6
+  },
+  {
+    calendar: "dangi",
+    isoReferenceYear: 1963,
+    year: 2001,
+    month: 5,
+    monthCode: "M04L",
+    day: 15
+  },
+  {
+    calendar: "dangi",
+    isoReferenceYear: 1971,
+    year: 2000,
+    month: 6,
+    day: 30
+  },
+  {
+    calendar: "ethiopic",
+    isoReferenceYear: 1971,
+    year: 2006,
+    month: 13,
+    day: 6
+  },
+  {
+    calendar: "ethioaa",
+    isoReferenceYear: 1971,
+    year: 2006,
+    month: 13,
+    day: 6
+  },
+  {
+    calendar: "gregory",
+    isoReferenceYear: 1972,
+    year: 2004,
+    month: 2,
+    day: 29
+  },
+  {
+    calendar: "hebrew",
+    isoReferenceYear: 1970,
+    year: 5779,
+    month: 6,
+    monthCode: "M05L",
+    day: 15
+  },
+  {
+    calendar: "hebrew",
+    isoReferenceYear: 1971,
+    year: 5776,
+    month: 2,
+    day: 30
+  },
+  {
+    calendar: "hebrew",
+    isoReferenceYear: 1971,
+    year: 5772,
+    month: 3,
+    day: 30
+  },
+  {
+    calendar: "indian",
+    isoReferenceYear: 1968,
+    year: 2002,
+    month: 1,
+    day: 31
+  },
+  {
+    calendar: "islamic",
+    isoReferenceYear: 1970,
+    year: 2001,
+    month: 1,
+    day: 30
+  },
+  {
+    calendar: "islamic-umalqura",
+    isoReferenceYear: 1969,
+    year: 2001,
+    month: 1,
+    day: 30
+  },
+  {
+    calendar: "islamic-tbla",
+    isoReferenceYear: 1971,
+    year: 2001,
+    month: 1,
+    day: 30
+  },
+  {
+    calendar: "islamic-civil",
+    isoReferenceYear: 1971,
+    year: 2001,
+    month: 1,
+    day: 30
+  },
+  {
+    calendar: "islamic-rgsa",
+    isoReferenceYear: 1970,
+    year: 2001,
+    month: 1,
+    day: 30
+  },
+  {
+    calendar: "islamicc",
+    isoReferenceYear: 1971,
+    year: 2001,
+    month: 1,
+    day: 30
+  },
+  {
+    calendar: "japanese",
+    isoReferenceYear: 1972,
+    year: 2004,
+    month: 2,
+    day: 29
+  },
+  {
+    calendar: "persian",
+    isoReferenceYear: 1972,
+    year: 2004,
+    month: 12,
+    day: 30
+  },
+  {
+    calendar: "roc",
+    isoReferenceYear: 1972,
+    year: 93,
+    month: 2,
+    day: 29
+  }
+];
+var i = 0;
+for (var test of monthDayCases) {
+  var id = test.calendar;
+  if ((id === "chinese" || id === "dangi") && hasOutdatedChineseIcuData ) {
+    if (test.monthCode === undefined)
+      test.monthCode = `M${ test.month.toString().padStart(2, "0") }`;
+    var {calendar, monthCode, month, day, year, isoReferenceYear} = test;
+    var md = Temporal.PlainMonthDay.from({
+      year,
+      month,
+      day,
+      calendar
+    });
+    var isoString = md.toString();
+    var mdFromIso = Temporal.PlainMonthDay.from(isoString);
+    assert.sameValue(mdFromIso, md);
+    var isoFields = md.getISOFields();
+    assert.sameValue(md.monthCode, monthCode);
+    assert.sameValue(md.day, day);
+    assert.sameValue(isoFields.isoYear, isoReferenceYear);
+    var md2 = Temporal.PlainMonthDay.from({
+      monthCode,
+      day,
+      calendar
+    });
+    var isoFields2 = md2.getISOFields();
+    assert.sameValue(md2.monthCode, monthCode);
+    assert.sameValue(md2.day, day);
+    assert.sameValue(isoFields2.isoYear, isoReferenceYear);
+    assert.sameValue(md.equals(md2), true);
+    assert.throws(RangeError, () => {
+      Temporal.PlainMonthDay.from({
+        monthCode: "M15",
+        day: 1,
+        calendar
+      }, { overflow: "reject" });
+    });
+    assert.throws(RangeError, () => {
+      Temporal.PlainMonthDay.from({
+        monthCode: "M15",
+        day: 1,
+        calendar
+      });
+    });
+    assert.throws(RangeError, () => {
+      Temporal.PlainMonthDay.from({
+        year,
+        month: 15,
+        day: 1,
+        calendar
+      }, { overflow: "reject" });
+    });
+    var constrained = Temporal.PlainMonthDay.from({
+      year,
+      month: 15,
+      day: 1,
+      calendar
+    });
+    var {monthCode: monthCodeConstrained} = constrained;
+    assert(monthCodeConstrained === "M12" || monthCodeConstrained === "M13");
+  };
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/persian-calendar.js b/js/src/tests/test262/staging/Intl402/Temporal/old/persian-calendar.js
new file mode 100644
index 0000000000..a3578f3208
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/persian-calendar.js
@@ -0,0 +1,93 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2023 Justin Grant. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: Persian calendar
+features: [Temporal]
+---*/
+
+// Test data obtained from ICU
+
+const tests = [
+  {
+    testYear: 1395,
+    inLeapYear: true,
+    daysInYear: 366,
+    daysInMonth12: 30,
+    isoYear: 2016,
+    isoMonth: 3,
+    isoDay: 20
+  },
+  {
+    testYear: 1396,
+    inLeapYear: false,
+    daysInYear: 365,
+    daysInMonth12: 29,
+    isoYear: 2017,
+    isoMonth: 3,
+    isoDay: 21
+  },
+  {
+    testYear: 1397,
+    inLeapYear: false,
+    daysInYear: 365,
+    daysInMonth12: 29,
+    isoYear: 2018,
+    isoMonth: 3,
+    isoDay: 21
+  },
+  {
+    testYear: 1398,
+    inLeapYear: false,
+    daysInYear: 365,
+    daysInMonth12: 29,
+    isoYear: 2019,
+    isoMonth: 3,
+    isoDay: 21
+  },
+  {
+    testYear: 1399,
+    inLeapYear: true,
+    daysInYear: 366,
+    daysInMonth12: 30,
+    isoYear: 2020,
+    isoMonth: 3,
+    isoDay: 20
+  },
+  {
+    testYear: 1400,
+    inLeapYear: false,
+    daysInYear: 365,
+    daysInMonth12: 29,
+    isoYear: 2021,
+    isoMonth: 3,
+    isoDay: 21
+  }
+];
+
+for (const test of tests) {
+  const { testYear, inLeapYear, daysInYear, daysInMonth12, isoYear, isoMonth, isoDay } = test;
+  const date = Temporal.PlainDate.from({ year: testYear, month: 1, day: 1, calendar: "persian" });
+  const isoFields = date.getISOFields();
+  assert.sameValue(date.calendarId, "persian");
+  assert.sameValue(date.year, testYear);
+  assert.sameValue(date.month, 1);
+  assert.sameValue(date.monthCode, "M01");
+  assert.sameValue(date.day, 1);
+  assert.sameValue(date.inLeapYear, inLeapYear);
+  assert.sameValue(date.daysInYear, daysInYear);
+  assert.sameValue(date.monthsInYear, 12);
+  assert.sameValue(date.dayOfYear, 1);
+  const startOfNextYear = date.with({ year: testYear + 1 });
+  const lastDayOfThisYear = startOfNextYear.subtract({ days: 1 });
+  assert.sameValue(lastDayOfThisYear.dayOfYear, daysInYear);
+  const dateMonth12 = date.with({ month: 12 });
+  assert.sameValue(dateMonth12.daysInMonth, daysInMonth12);
+  assert.sameValue(isoYear, isoFields.isoYear);
+  assert.sameValue(isoMonth, isoFields.isoMonth);
+  assert.sameValue(isoDay, isoFields.isoDay);
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/shell.js b/js/src/tests/test262/staging/Intl402/Temporal/old/shell.js
new file mode 100644
index 0000000000..276ee734ff
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/shell.js
@@ -0,0 +1,329 @@
+// GENERATED, DO NOT EDIT
+// file: deepEqual.js
+// Copyright 2019 Ron Buckton. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: >
+  Compare two values structurally
+defines: [assert.deepEqual]
+---*/
+
+assert.deepEqual = function(actual, expected, message) {
+  var format = assert.deepEqual.format;
+  assert(
+    assert.deepEqual._compare(actual, expected),
+    `Expected ${format(actual)} to be structurally equal to ${format(expected)}. ${(message || '')}`
+  );
+};
+
+assert.deepEqual.format = function(value, seen) {
+  switch (typeof value) {
+    case 'string':
+      return typeof JSON !== "undefined" ? JSON.stringify(value) : `"${value}"`;
+    case 'number':
+    case 'boolean':
+    case 'symbol':
+    case 'bigint':
+      return value.toString();
+    case 'undefined':
+      return 'undefined';
+    case 'function':
+      return `[Function${value.name ? `: ${value.name}` : ''}]`;
+    case 'object':
+      if (value === null) return 'null';
+      if (value instanceof Date) return `Date "${value.toISOString()}"`;
+      if (value instanceof RegExp) return value.toString();
+      if (!seen) {
+        seen = {
+          counter: 0,
+          map: new Map()
+        };
+      }
+
+      let usage = seen.map.get(value);
+      if (usage) {
+        usage.used = true;
+        return `[Ref: #${usage.id}]`;
+      }
+
+      usage = { id: ++seen.counter, used: false };
+      seen.map.set(value, usage);
+
+      if (typeof Set !== "undefined" && value instanceof Set) {
+        return `Set {${Array.from(value).map(value => assert.deepEqual.format(value, seen)).join(', ')}}${usage.used ? ` as #${usage.id}` : ''}`;
+      }
+      if (typeof Map !== "undefined" && value instanceof Map) {
+        return `Map {${Array.from(value).map(pair => `${assert.deepEqual.format(pair[0], seen)} => ${assert.deepEqual.format(pair[1], seen)}}`).join(', ')}}${usage.used ? ` as #${usage.id}` : ''}`;
+      }
+      if (Array.isArray ? Array.isArray(value) : value instanceof Array) {
+        return `[${value.map(value => assert.deepEqual.format(value, seen)).join(', ')}]${usage.used ? ` as #${usage.id}` : ''}`;
+      }
+      let tag = Symbol.toStringTag in value ? value[Symbol.toStringTag] : 'Object';
+      if (tag === 'Object' && Object.getPrototypeOf(value) === null) {
+        tag = '[Object: null prototype]';
+      }
+      return `${tag ? `${tag} ` : ''}{ ${Object.keys(value).map(key => `${key.toString()}: ${assert.deepEqual.format(value[key], seen)}`).join(', ')} }${usage.used ? ` as #${usage.id}` : ''}`;
+    default:
+      return typeof value;
+  }
+};
+
+assert.deepEqual._compare = (function () {
+  var EQUAL = 1;
+  var NOT_EQUAL = -1;
+  var UNKNOWN = 0;
+
+  function deepEqual(a, b) {
+    return compareEquality(a, b) === EQUAL;
+  }
+
+  function compareEquality(a, b, cache) {
+    return compareIf(a, b, isOptional, compareOptionality)
+      || compareIf(a, b, isPrimitiveEquatable, comparePrimitiveEquality)
+      || compareIf(a, b, isObjectEquatable, compareObjectEquality, cache)
+      || NOT_EQUAL;
+  }
+
+  function compareIf(a, b, test, compare, cache) {
+    return !test(a)
+      ? !test(b) ? UNKNOWN : NOT_EQUAL
+      : !test(b) ? NOT_EQUAL : cacheComparison(a, b, compare, cache);
+  }
+
+  function tryCompareStrictEquality(a, b) {
+    return a === b ? EQUAL : UNKNOWN;
+  }
+
+  function tryCompareTypeOfEquality(a, b) {
+    return typeof a !== typeof b ? NOT_EQUAL : UNKNOWN;
+  }
+
+  function tryCompareToStringTagEquality(a, b) {
+    var aTag = Symbol.toStringTag in a ? a[Symbol.toStringTag] : undefined;
+    var bTag = Symbol.toStringTag in b ? b[Symbol.toStringTag] : undefined;
+    return aTag !== bTag ? NOT_EQUAL : UNKNOWN;
+  }
+
+  function isOptional(value) {
+    return value === undefined
+      || value === null;
+  }
+
+  function compareOptionality(a, b) {
+    return tryCompareStrictEquality(a, b)
+      || NOT_EQUAL;
+  }
+
+  function isPrimitiveEquatable(value) {
+    switch (typeof value) {
+      case 'string':
+      case 'number':
+      case 'bigint':
+      case 'boolean':
+      case 'symbol':
+        return true;
+      default:
+        return isBoxed(value);
+    }
+  }
+
+  function comparePrimitiveEquality(a, b) {
+    if (isBoxed(a)) a = a.valueOf();
+    if (isBoxed(b)) b = b.valueOf();
+    return tryCompareStrictEquality(a, b)
+      || tryCompareTypeOfEquality(a, b)
+      || compareIf(a, b, isNaNEquatable, compareNaNEquality)
+      || NOT_EQUAL;
+  }
+
+  function isNaNEquatable(value) {
+    return typeof value === 'number';
+  }
+
+  function compareNaNEquality(a, b) {
+    return isNaN(a) && isNaN(b) ? EQUAL : NOT_EQUAL;
+  }
+
+  function isObjectEquatable(value) {
+    return typeof value === 'object';
+  }
+
+  function compareObjectEquality(a, b, cache) {
+    if (!cache) cache = new Map();
+    return getCache(cache, a, b)
+      || setCache(cache, a, b, EQUAL) // consider equal for now
+      || cacheComparison(a, b, tryCompareStrictEquality, cache)
+      || cacheComparison(a, b, tryCompareToStringTagEquality, cache)
+      || compareIf(a, b, isValueOfEquatable, compareValueOfEquality)
+      || compareIf(a, b, isToStringEquatable, compareToStringEquality)
+      || compareIf(a, b, isArrayLikeEquatable, compareArrayLikeEquality, cache)
+      || compareIf(a, b, isStructurallyEquatable, compareStructuralEquality, cache)
+      || compareIf(a, b, isIterableEquatable, compareIterableEquality, cache)
+      || cacheComparison(a, b, fail, cache);
+  }
+
+  function isBoxed(value) {
+    return value instanceof String
+      || value instanceof Number
+      || value instanceof Boolean
+      || typeof Symbol === 'function' && value instanceof Symbol
+      || typeof BigInt === 'function' && value instanceof BigInt;
+  }
+
+  function isValueOfEquatable(value) {
+    return value instanceof Date;
+  }
+
+  function compareValueOfEquality(a, b) {
+    return compareIf(a.valueOf(), b.valueOf(), isPrimitiveEquatable, comparePrimitiveEquality)
+      || NOT_EQUAL;
+  }
+
+  function isToStringEquatable(value) {
+    return value instanceof RegExp;
+  }
+
+  function compareToStringEquality(a, b) {
+    return compareIf(a.toString(), b.toString(), isPrimitiveEquatable, comparePrimitiveEquality)
+      || NOT_EQUAL;
+  }
+
+  function isArrayLikeEquatable(value) {
+    return (Array.isArray ? Array.isArray(value) : value instanceof Array)
+      || (typeof Uint8Array === 'function' && value instanceof Uint8Array)
+      || (typeof Uint8ClampedArray === 'function' && value instanceof Uint8ClampedArray)
+      || (typeof Uint16Array === 'function' && value instanceof Uint16Array)
+      || (typeof Uint32Array === 'function' && value instanceof Uint32Array)
+      || (typeof Int8Array === 'function' && value instanceof Int8Array)
+      || (typeof Int16Array === 'function' && value instanceof Int16Array)
+      || (typeof Int32Array === 'function' && value instanceof Int32Array)
+      || (typeof Float32Array === 'function' && value instanceof Float32Array)
+      || (typeof Float64Array === 'function' && value instanceof Float64Array)
+      || (typeof BigUint64Array === 'function' && value instanceof BigUint64Array)
+      || (typeof BigInt64Array === 'function' && value instanceof BigInt64Array);
+  }
+
+  function compareArrayLikeEquality(a, b, cache) {
+    if (a.length !== b.length) return NOT_EQUAL;
+    for (var i = 0; i < a.length; i++) {
+      if (compareEquality(a[i], b[i], cache) === NOT_EQUAL) {
+        return NOT_EQUAL;
+      }
+    }
+    return EQUAL;
+  }
+
+  function isStructurallyEquatable(value) {
+    return !(typeof Promise === 'function' && value instanceof Promise // only comparable by reference
+      || typeof WeakMap === 'function' && value instanceof WeakMap // only comparable by reference
+      || typeof WeakSet === 'function' && value instanceof WeakSet // only comparable by reference
+      || typeof Map === 'function' && value instanceof Map // comparable via @@iterator
+      || typeof Set === 'function' && value instanceof Set); // comparable via @@iterator
+  }
+
+  function compareStructuralEquality(a, b, cache) {
+    var aKeys = [];
+    for (var key in a) aKeys.push(key);
+
+    var bKeys = [];
+    for (var key in b) bKeys.push(key);
+
+    if (aKeys.length !== bKeys.length) {
+      return NOT_EQUAL;
+    }
+
+    aKeys.sort();
+    bKeys.sort();
+
+    for (var i = 0; i < aKeys.length; i++) {
+      var aKey = aKeys[i];
+      var bKey = bKeys[i];
+      if (compareEquality(aKey, bKey, cache) === NOT_EQUAL) {
+        return NOT_EQUAL;
+      }
+      if (compareEquality(a[aKey], b[bKey], cache) === NOT_EQUAL) {
+        return NOT_EQUAL;
+      }
+    }
+
+    return compareIf(a, b, isIterableEquatable, compareIterableEquality, cache)
+      || EQUAL;
+  }
+
+  function isIterableEquatable(value) {
+    return typeof Symbol === 'function'
+      && typeof value[Symbol.iterator] === 'function';
+  }
+
+  function compareIteratorEquality(a, b, cache) {
+    if (typeof Map === 'function' && a instanceof Map && b instanceof Map ||
+      typeof Set === 'function' && a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) return NOT_EQUAL; // exit early if we detect a difference in size
+    }
+
+    var ar, br;
+    while (true) {
+      ar = a.next();
+      br = b.next();
+      if (ar.done) {
+        if (br.done) return EQUAL;
+        if (b.return) b.return();
+        return NOT_EQUAL;
+      }
+      if (br.done) {
+        if (a.return) a.return();
+        return NOT_EQUAL;
+      }
+      if (compareEquality(ar.value, br.value, cache) === NOT_EQUAL) {
+        if (a.return) a.return();
+        if (b.return) b.return();
+        return NOT_EQUAL;
+      }
+    }
+  }
+
+  function compareIterableEquality(a, b, cache) {
+    return compareIteratorEquality(a[Symbol.iterator](), b[Symbol.iterator](), cache);
+  }
+
+  function cacheComparison(a, b, compare, cache) {
+    var result = compare(a, b, cache);
+    if (cache && (result === EQUAL || result === NOT_EQUAL)) {
+      setCache(cache, a, b, /** @type {EQUAL | NOT_EQUAL} */(result));
+    }
+    return result;
+  }
+
+  function fail() {
+    return NOT_EQUAL;
+  }
+
+  function setCache(cache, left, right, result) {
+    var otherCache;
+
+    otherCache = cache.get(left);
+    if (!otherCache) cache.set(left, otherCache = new Map());
+    otherCache.set(right, result);
+
+    otherCache = cache.get(right);
+    if (!otherCache) cache.set(right, otherCache = new Map());
+    otherCache.set(left, result);
+  }
+
+  function getCache(cache, left, right) {
+    var otherCache;
+    var result;
+
+    otherCache = cache.get(left);
+    result = otherCache && otherCache.get(right);
+    if (result) return result;
+
+    otherCache = cache.get(right);
+    result = otherCache && otherCache.get(left);
+    if (result) return result;
+
+    return UNKNOWN;
+  }
+
+  return deepEqual;
+})();
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/time-toLocaleString.js b/js/src/tests/test262/staging/Intl402/Temporal/old/time-toLocaleString.js
new file mode 100644
index 0000000000..a521123333
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/time-toLocaleString.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: time.toLocaleString()
+features: [Temporal]
+---*/
+
+// Tolerate implementation variance by expecting consistency without being prescriptive.
+// TODO: can we change tests to be less reliant on CLDR formats while still testing that
+// Temporal and Intl are behaving as expected?
+const usDayPeriodSpace =
+  new Intl.DateTimeFormat("en-US", { timeStyle: "short" })
+    .formatToParts(0)
+    .find((part, i, parts) => part.type === "literal" && parts[i + 1].type === "dayPeriod")?.value || "";
+
+var time = Temporal.PlainTime.from("1976-11-18T15:23:30");
+assert.sameValue(`${time.toLocaleString("en-US", { timeZone: "America/New_York" })}`, `3:23:30${usDayPeriodSpace}PM`);
+assert.sameValue(`${time.toLocaleString("de-AT", { timeZone: "Europe/Vienna" })}`, "15:23:30");
+
+// should ignore units not in the data type
+assert.sameValue(time.toLocaleString("en-US", { timeZoneName: "long" }), `3:23:30${usDayPeriodSpace}PM`);
+assert.sameValue(time.toLocaleString("en-US", { year: "numeric" }), `3:23:30${usDayPeriodSpace}PM`);
+assert.sameValue(time.toLocaleString("en-US", { month: "numeric" }), `3:23:30${usDayPeriodSpace}PM`);
+assert.sameValue(time.toLocaleString("en-US", { day: "numeric" }), `3:23:30${usDayPeriodSpace}PM`);
+assert.sameValue(time.toLocaleString("en-US", { weekday: "long" }), `3:23:30${usDayPeriodSpace}PM`);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/timezone-america-la.js b/js/src/tests/test262/staging/Intl402/Temporal/old/timezone-america-la.js
new file mode 100644
index 0000000000..662f54d05c
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/timezone-america-la.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: America/Los_Angeles
+features: [Temporal]
+---*/
+
+var zone = new Temporal.TimeZone("America/Los_Angeles");
+var inst = new Temporal.Instant(0n);
+var dtm = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789);
+assert.sameValue(zone.id, `${ zone }`)
+assert.sameValue(zone.getOffsetNanosecondsFor(inst), -8 * 3600000000000)
+assert.sameValue(zone.getOffsetStringFor(inst), "-08:00")
+assert(zone.getInstantFor(dtm) instanceof Temporal.Instant)
+for (var i = 0, txn = inst; i < 4; i++) {
+  var transition = zone.getNextTransition(txn);
+  assert(transition instanceof Temporal.Instant);
+  assert(!transition.equals(txn));
+  txn = transition;
+}
+for (var i = 0, txn = inst; i < 4; i++) {
+  var transition = zone.getPreviousTransition(txn);
+  assert(transition instanceof Temporal.Instant);
+  assert(!transition.equals(txn));
+  txn = transition;
+}
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/tzdb-string-parsing.js b/js/src/tests/test262/staging/Intl402/Temporal/old/tzdb-string-parsing.js
new file mode 100644
index 0000000000..16690270bc
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/tzdb-string-parsing.js
@@ -0,0 +1,101 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: String parsing cases that require a TZDB in the implementation
+features: [Temporal]
+---*/
+
+// parses with an IANA zone but no offset (with disambiguation)
+var zdt = Temporal.ZonedDateTime.from("2020-03-08T02:30[America/Los_Angeles]", { disambiguation: "earlier" });
+assert.sameValue(zdt.toString(), "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+
+// "Z" means preserve the exact time in the given IANA time zone
+var zdt = Temporal.ZonedDateTime.from("2020-03-08T09:00:00Z[America/Los_Angeles]");
+assert.sameValue(zdt.toString(), "2020-03-08T01:00:00-08:00[America/Los_Angeles]");
+
+// Offset options
+
+// { offset: 'prefer' } if offset matches time zone (first 1:30 when DST ends)
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T01:30-07:00[America/Los_Angeles]", { offset: "prefer" });
+assert.sameValue(zdt.toString(), "2020-11-01T01:30:00-07:00[America/Los_Angeles]");
+
+// { offset: 'prefer' } if offset matches time zone (second 1:30 when DST ends)
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T01:30-08:00[America/Los_Angeles]", { offset: "prefer" });
+assert.sameValue(zdt.toString(), "2020-11-01T01:30:00-08:00[America/Los_Angeles]");
+
+// { offset: 'prefer' } if offset does not match time zone
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-07:00[America/Los_Angeles]", { offset: "prefer" });
+assert.sameValue(zdt.toString(), "2020-11-01T04:00:00-08:00[America/Los_Angeles]");
+
+// { offset: 'ignore' } uses time zone only
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-12:00[America/Los_Angeles]", { offset: "ignore" });
+assert.sameValue(zdt.toString(), "2020-11-01T04:00:00-08:00[America/Los_Angeles]");
+
+// { offset: 'use' } uses offset only
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-07:00[America/Los_Angeles]", { offset: "use" });
+assert.sameValue(zdt.toString(), "2020-11-01T03:00:00-08:00[America/Los_Angeles]");
+
+// Disambiguation options
+
+// plain datetime with multiple instants - Fall DST in Brazil
+var str = "2019-02-16T23:45[America/Sao_Paulo]";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "compatible" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "earlier" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "later" }) }`, "2019-02-16T23:45:00-03:00[America/Sao_Paulo]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, { disambiguation: "reject" }));
+
+// plain datetime with multiple instants - Spring DST in Los Angeles
+var str = "2020-03-08T02:30[America/Los_Angeles]";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "compatible" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "earlier" }) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "later" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, { disambiguation: "reject" }));
+
+// uses disambiguation if offset is ignored
+var str = "2020-03-08T02:30[America/Los_Angeles]";
+var offset = "ignore";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+  offset,
+  disambiguation: "compatible"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+  offset,
+  disambiguation: "earlier"
+}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+  offset,
+  disambiguation: "later"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, {
+  offset,
+  disambiguation: "reject"
+}));
+
+// uses disambiguation if offset is wrong and option is prefer
+var str = "2020-03-08T02:30-23:59[America/Los_Angeles]";
+var offset = "prefer";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+  offset,
+  disambiguation: "compatible"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+  offset,
+  disambiguation: "earlier"
+}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+  offset,
+  disambiguation: "later"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, {
+  offset,
+  disambiguation: "reject"
+}));
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/tzdb-transitions.js b/js/src/tests/test262/staging/Intl402/Temporal/old/tzdb-transitions.js
new file mode 100644
index 0000000000..52978e40fb
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/tzdb-transitions.js
@@ -0,0 +1,47 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: Tests that are impractical to do without a TZDB
+features: [Temporal]
+---*/
+
+// getNextTransition()
+
+var nyc = Temporal.TimeZone.from("America/New_York");
+
+// should not have bug #510
+var a1 = Temporal.Instant.from("2019-04-16T21:01Z");
+var a2 = Temporal.Instant.from("1800-01-01T00:00Z");
+assert.sameValue(nyc.getNextTransition(a1).toString(), "2019-11-03T06:00:00Z");
+assert.sameValue(nyc.getNextTransition(a2).toString(), "1883-11-18T17:00:00Z");
+
+// should not return the same as its input if the input is a transition point
+var inst = Temporal.Instant.from("2019-01-01T00:00Z");
+assert.sameValue(`${ nyc.getNextTransition(inst) }`, "2019-03-10T07:00:00Z");
+assert.sameValue(`${ nyc.getNextTransition(nyc.getNextTransition(inst)) }`, "2019-11-03T06:00:00Z");
+
+// casts argument
+assert.sameValue(`${ nyc.getNextTransition("2019-04-16T21:01Z") }`, "2019-11-03T06:00:00Z");
+
+// getPreviousTransition()
+
+var london = Temporal.TimeZone.from("Europe/London");
+
+// should return first and last transition
+var a1 = Temporal.Instant.from("2020-06-11T21:01Z");
+var a2 = Temporal.Instant.from("1848-01-01T00:00Z");
+assert.sameValue(london.getPreviousTransition(a1).toString(), "2020-03-29T01:00:00Z");
+assert.sameValue(london.getPreviousTransition(a2).toString(), "1847-12-01T00:01:15Z");
+
+// should not return the same as its input if the input is a transition point
+var inst = Temporal.Instant.from("2020-06-01T00:00Z");
+assert.sameValue(`${ london.getPreviousTransition(inst) }`, "2020-03-29T01:00:00Z");
+assert.sameValue(`${ london.getPreviousTransition(london.getPreviousTransition(inst)) }`, "2019-10-27T01:00:00Z");
+
+// casts argument
+assert.sameValue(`${ london.getPreviousTransition("2020-06-11T21:01Z") }`, "2020-03-29T01:00:00Z");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/yearmonth-toLocaleString.js b/js/src/tests/test262/staging/Intl402/Temporal/old/yearmonth-toLocaleString.js
new file mode 100644
index 0000000000..c92aa506d5
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/yearmonth-toLocaleString.js
@@ -0,0 +1,42 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-intl
+description: yearmonth.toLocaleString()
+features: [Temporal]
+---*/
+
+// Tolerate implementation variance by expecting consistency without being prescriptive.
+// TODO: can we change tests to be less reliant on CLDR formats while still testing that
+// Temporal and Intl are behaving as expected?
+// Workarounds for https://unicode-org.atlassian.net/browse/CLDR-16243
+const deMonthDayRangeSeparator = new Intl.DateTimeFormat("de-AT", { month: "numeric", day: "numeric" })
+  .formatRangeToParts(1 * 86400 * 1000, 90 * 86400 * 1000)
+  .find((part) => part.type === "literal" && part.source === "shared").value;
+const deMonthYearSeparator = new Intl.DateTimeFormat("de-AT", { year: "numeric", month: "numeric" })
+  .formatToParts(0)
+  .find((part) => part.type === "literal").value;
+
+var calendar = new Intl.DateTimeFormat("en-US").resolvedOptions().calendar;
+var yearmonth = Temporal.PlainYearMonth.from({
+  year: 1976,
+  month: 11,
+  calendar
+});
+assert.sameValue(`${yearmonth.toLocaleString("en-US", { timeZone: "America/New_York" })}`, "11/1976");
+assert.sameValue(
+  `${yearmonth.toLocaleString("de-AT", { timeZone: "Europe/Vienna", calendar })}`,
+  `11${deMonthYearSeparator}1976`
+);
+
+// should ignore units not in the data type
+assert.sameValue(yearmonth.toLocaleString("en-US", { timeZoneName: "long" }), "11/1976");
+assert.sameValue(yearmonth.toLocaleString("en-US", { day: "numeric" }), "11/1976");
+assert.sameValue(yearmonth.toLocaleString("en-US", { hour: "numeric" }), "11/1976");
+assert.sameValue(yearmonth.toLocaleString("en-US", { minute: "numeric" }), "11/1976");
+assert.sameValue(yearmonth.toLocaleString("en-US", { second: "numeric" }), "11/1976");
+assert.sameValue(yearmonth.toLocaleString("en-US", { weekday: "long" }), "11/1976");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/old/zoneddatetime-dst-corner-cases.js b/js/src/tests/test262/staging/Intl402/Temporal/old/zoneddatetime-dst-corner-cases.js
new file mode 100644
index 0000000000..d66a8d0715
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/old/zoneddatetime-dst-corner-cases.js
@@ -0,0 +1,29 @@
+// |reftest| skip-if(!this.hasOwnProperty('Temporal')) -- Temporal is not enabled unconditionally
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Corner cases of time zone offset shifts
+features: [Temporal]
+---*/
+
+// hoursInDay works with non-hour DST change
+var zdt1 = Temporal.ZonedDateTime.from("2020-10-04T12:00[Australia/Lord_Howe]");
+assert.sameValue(zdt1.hoursInDay, 23.5);
+var zdt2 = Temporal.ZonedDateTime.from("2020-04-05T12:00[Australia/Lord_Howe]");
+assert.sameValue(zdt2.hoursInDay, 24.5);
+
+// hoursInDay works with non-half-hour DST change
+var zdt = Temporal.ZonedDateTime.from("1933-01-01T12:00[Asia/Singapore]");
+assert(Math.abs(zdt.hoursInDay - 23.666666666666668) < Number.EPSILON);
+
+// hoursInDay works when day starts at 1:00 due to DST start at midnight
+var zdt = Temporal.ZonedDateTime.from("2015-10-18T12:00:00-02:00[America/Sao_Paulo]");
+assert.sameValue(zdt.hoursInDay, 23);
+
+// startOfDay works when day starts at 1:00 due to DST start at midnight
+var zdt = Temporal.ZonedDateTime.from("2015-10-18T12:00:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ zdt.startOfDay().toPlainTime() }`, "01:00:00");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/staging/Intl402/Temporal/shell.js b/js/src/tests/test262/staging/Intl402/Temporal/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/Temporal/shell.js
diff --git a/js/src/tests/test262/staging/Intl402/browser.js b/js/src/tests/test262/staging/Intl402/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/browser.js
diff --git a/js/src/tests/test262/staging/Intl402/shell.js b/js/src/tests/test262/staging/Intl402/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/staging/Intl402/shell.js