April 2026 rebase, part 2

lib/duration.ts

@@ -178,7 +178,7 @@ export class Duration implements Temporal.Duration {
 
     let largestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'largestUnit');
     let { plainRelativeTo, zonedRelativeTo } = ES.GetTemporalRelativeToOption(roundTo);
-    const roundingIncrement = ES.GetTemporalRoundingIncrementOption(roundTo);
+    const roundingIncrement = ES.GetRoundingIncrementOption(roundTo);
     const roundingMode = ES.GetRoundingModeOption(roundTo, 'halfExpand');
     let smallestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'smallestUnit');
     ES.ValidateTemporalUnitValue(smallestUnit, 'datetime');

lib/instant.ts

@@ -52,7 +52,7 @@ export class Instant implements Temporal.Instant {
       typeof roundToParam === 'string'
         ? (ES.CreateOnePropObject('smallestUnit', roundToParam) as Exclude<typeof roundToParam, string>)
         : ES.GetOptionsObject(roundToParam);
-    const roundingIncrement = ES.GetTemporalRoundingIncrementOption(roundTo);
+    const roundingIncrement = ES.GetRoundingIncrementOption(roundTo);
     const roundingMode = ES.GetRoundingModeOption(roundTo, 'halfExpand');
     const smallestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'smallestUnit', ES.REQUIRED);
     ES.ValidateTemporalUnitValue(smallestUnit, 'time');
@@ -82,9 +82,9 @@ export class Instant implements Temporal.Instant {
     const digits = ES.GetTemporalFractionalSecondDigitsOption(resolvedOptions);
     const roundingMode = ES.GetRoundingModeOption(resolvedOptions, 'trunc');
     const smallestUnit = ES.GetTemporalUnitValuedOption(resolvedOptions, 'smallestUnit');
+    let timeZone = resolvedOptions.timeZone;
     ES.ValidateTemporalUnitValue(smallestUnit, 'time');
     if (smallestUnit === 'hour') throw new RangeError('smallestUnit must be a time unit other than "hour"');
-    let timeZone = resolvedOptions.timeZone;
     if (timeZone !== undefined) timeZone = ES.ToTemporalTimeZoneIdentifier(timeZone);
     const { precision, unit, increment } = ES.ToSecondsStringPrecisionRecord(smallestUnit, digits);
     const ns = GetSlot(this, EPOCHNANOSECONDS);

lib/monthcode.ts

@@ -1,14 +1,21 @@
 import { ToPrimitiveRequireString } from './primitive';
-import { monthCode as MONTH_CODE_REGEX } from './regex';
+
+const digitsForMonthNumber = Array.from({ length: 100 }, (_, i) => (i < 10 ? `0${i}` : `${i}`));
 
 export function ParseMonthCode(argument: unknown) {
   const value = ToPrimitiveRequireString(argument);
-  const match = MONTH_CODE_REGEX.exec(value);
-  if (!match) throw new RangeError(`bad month code ${value}; must match M01-M99 or M00L-M99L`);
-  return {
-    monthNumber: +(match[1] ?? match[3] ?? match[5]),
-    isLeapMonth: (match[2] ?? match[4] ?? match[6]) === 'L'
-  };
+  const digits = value.slice(1, 3);
+  const monthNumber = digits.length === 2 ? +digits : -1; // -1 ensures failure
+  const isLeapMonth = value.length === 4;
+  if (
+    !(monthNumber >= 0) ||
+    digits !== digitsForMonthNumber[monthNumber] ||
+    value[0] !== 'M' ||
+    (isLeapMonth ? value[3] !== 'L' : value.length !== 3 || monthNumber === 0)
+  ) {
+    throw new RangeError(`bad month code ${value}; must match M01-M99 or M00L-M99L`);
+  }
+  return { monthNumber, isLeapMonth };
 }
 
 export function CreateMonthCode(monthNumber: number, isLeapMonth: boolean) {

lib/plaindate.ts

@@ -94,7 +94,10 @@ export class PlainDate implements Temporal.PlainDate {
   withCalendar(calendarParam: Params['withCalendar'][0]): Return['withCalendar'] {
     ES.CheckReceiver(this, ES.IsTemporalDate);
     const calendar = ES.ToTemporalCalendarIdentifier(calendarParam);
-    return ES.CreateTemporalDate(GetSlot(this, ISO_DATE), calendar);
+    // Don't reuse the same ISODate object, as it should start with a fresh
+    // calendar cache
+    const { year, month, day } = GetSlot(this, ISO_DATE);
+    return ES.CreateTemporalDate({ year, month, day }, calendar);
   }
   add(temporalDurationLike: Params['add'][0], options: Params['add'][1] = undefined): Return['add'] {
     ES.CheckReceiver(this, ES.IsTemporalDate);

lib/plaindatetime.ts

@@ -140,7 +140,13 @@ export class PlainDateTime implements Temporal.PlainDateTime {
   withCalendar(calendarParam: Params['withCalendar'][0]): Return['withCalendar'] {
     ES.CheckReceiver(this, ES.IsTemporalDateTime);
     const calendar = ES.ToTemporalCalendarIdentifier(calendarParam);
-    return ES.CreateTemporalDateTime(GetSlot(this, ISO_DATE_TIME), calendar);
+    // Don't reuse the same ISODate object, as it should start with a fresh
+    // calendar cache
+    const {
+      isoDate: { year, month, day },
+      time
+    } = GetSlot(this, ISO_DATE_TIME);
+    return ES.CreateTemporalDateTime(ES.CombineISODateAndTimeRecord({ year, month, day }, time), calendar);
   }
   add(temporalDurationLike: Params['add'][0], options: Params['add'][1] = undefined): Return['add'] {
     ES.CheckReceiver(this, ES.IsTemporalDateTime);
@@ -168,7 +174,7 @@ export class PlainDateTime implements Temporal.PlainDateTime {
       typeof roundToParam === 'string'
         ? (ES.CreateOnePropObject('smallestUnit', roundToParam) as Exclude<typeof roundToParam, string>)
         : ES.GetOptionsObject(roundToParam);
-    const roundingIncrement = ES.GetTemporalRoundingIncrementOption(roundTo);
+    const roundingIncrement = ES.GetRoundingIncrementOption(roundTo);
     const roundingMode = ES.GetRoundingModeOption(roundTo, 'halfExpand');
     const smallestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'smallestUnit', ES.REQUIRED);
     ES.ValidateTemporalUnitValue(smallestUnit, 'time', ['day']);

lib/plaintime.ts

@@ -92,7 +92,7 @@ export class PlainTime implements Temporal.PlainTime {
       typeof roundToParam === 'string'
         ? (ES.CreateOnePropObject('smallestUnit', roundToParam) as Exclude<typeof roundToParam, string>)
         : ES.GetOptionsObject(roundToParam);
-    const roundingIncrement = ES.GetTemporalRoundingIncrementOption(roundTo);
+    const roundingIncrement = ES.GetRoundingIncrementOption(roundTo);
     const roundingMode = ES.GetRoundingModeOption(roundTo, 'halfExpand');
     const smallestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'smallestUnit', ES.REQUIRED);
     ES.ValidateTemporalUnitValue(smallestUnit, 'time');

lib/regex.ts

@@ -57,5 +57,3 @@ const fraction = /(\d+)(?:[.,](\d{1,9}))?/;
 const durationDate = /(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?/;
 const durationTime = new RegExp(`(?:${fraction.source}H)?(?:${fraction.source}M)?(?:${fraction.source}S)?`);
 export const duration = new RegExp(`^([+-])?P${durationDate.source}(?:T(?!$)${durationTime.source})?$`, 'i');
-
-export const monthCode = /^M(?:(00)(L)|(0[1-9])(L)?|([1-9][0-9])(L)?)$/;

lib/zoneddatetime.ts

@@ -236,7 +236,7 @@ export class ZonedDateTime implements Temporal.ZonedDateTime {
       typeof roundToParam === 'string'
         ? (ES.CreateOnePropObject('smallestUnit', roundToParam) as Exclude<typeof roundToParam, string>)
         : ES.GetOptionsObject(roundToParam);
-    const roundingIncrement = ES.GetTemporalRoundingIncrementOption(roundTo);
+    const roundingIncrement = ES.GetRoundingIncrementOption(roundTo);
     const roundingMode = ES.GetRoundingModeOption(roundTo, 'halfExpand');
     const smallestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'smallestUnit', ES.REQUIRED);
     ES.ValidateTemporalUnitValue(smallestUnit, 'time', ['day']);
@@ -331,9 +331,9 @@ export class ZonedDateTime implements Temporal.ZonedDateTime {
     const showOffset = ES.GetTemporalShowOffsetOption(resolvedOptions);
     const roundingMode = ES.GetRoundingModeOption(resolvedOptions, 'trunc');
     const smallestUnit = ES.GetTemporalUnitValuedOption(resolvedOptions, 'smallestUnit');
+    const showTimeZone = ES.GetTemporalShowTimeZoneNameOption(resolvedOptions);
     ES.ValidateTemporalUnitValue(smallestUnit, 'time');
     if (smallestUnit === 'hour') throw new RangeError('smallestUnit must be a time unit other than "hour"');
-    const showTimeZone = ES.GetTemporalShowTimeZoneNameOption(resolvedOptions);
     const { precision, unit, increment } = ES.ToSecondsStringPrecisionRecord(smallestUnit, digits);
     return ES.TemporalZonedDateTimeToString(this, precision, showCalendar, showTimeZone, showOffset, {
       unit,

test/monthcode.mjs

@@ -0,0 +1,138 @@
+import { describe, expect, it } from '@jest/globals';
+import { CreateMonthCode, ParseMonthCode } from '../lib/monthcode';
+
+// Avoid these wrappers in new tests:
+function deepEqual(a, b) {
+  expect(a).toEqual(b);
+}
+function equal(a, b) {
+  expect(a).toBe(b);
+}
+function throws(f, cons) {
+  expect(f).toThrow(cons);
+}
+
+function badMonthCode(code) {
+  throws(() => ParseMonthCode(code), RangeError, code);
+}
+
+describe('ParseMonthCode', () => {
+  it('all Gregorian month codes', () => {
+    ['M01', 'M02', 'M03', 'M04', 'M05', 'M06', 'M07', 'M08', 'M09', 'M10', 'M11', 'M12'].forEach((code, ix) => {
+      deepEqual(ParseMonthCode(code), { monthNumber: ix + 1, isLeapMonth: false });
+    });
+  });
+  it('Intercalary month 13', () => {
+    deepEqual(ParseMonthCode('M13'), { monthNumber: 13, isLeapMonth: false });
+  });
+  it('all Chinese leap month codes', () => {
+    ['M01L', 'M02L', 'M03L', 'M04L', 'M05L', 'M06L', 'M07L', 'M08L', 'M09L', 'M10L', 'M11L', 'M12L'].forEach(
+      (code, ix) => {
+        deepEqual(ParseMonthCode(code), { monthNumber: ix + 1, isLeapMonth: true });
+      }
+    );
+  });
+  it('M00L (valid but does not occur in currently supported calendars)', () => {
+    deepEqual(ParseMonthCode('M00L'), { monthNumber: 0, isLeapMonth: true });
+  });
+  it('various other month codes that do not occur in currently supported calendars', () => {
+    const tests = [
+      ['M14', 14, false],
+      ['M13L', 13, true],
+      ['M99', 99, false],
+      ['M99L', 99, true],
+      ['M42', 42, false],
+      ['M57L', 57, true]
+    ];
+    for (const [code, monthNumber, isLeapMonth] of tests) {
+      deepEqual(ParseMonthCode(code), { monthNumber, isLeapMonth });
+    }
+  });
+  it('goes through ToPrimitive', () => {
+    ['toString', Symbol.toPrimitive].forEach((prop) => {
+      const convertibleObject = {
+        [prop]() {
+          return 'M01';
+        }
+      };
+      deepEqual(ParseMonthCode(convertibleObject), { monthNumber: 1, isLeapMonth: false }, prop);
+    });
+  });
+  it('no M00', () => badMonthCode('M00'));
+  it('missing leading zero', () => {
+    badMonthCode('M1');
+    badMonthCode('M5L');
+  });
+  it('number too big', () => {
+    badMonthCode('M100');
+    badMonthCode('M999L');
+  });
+  it('negative number', () => {
+    badMonthCode('M-3');
+    badMonthCode('M-7L');
+  });
+  it('decimal point', () => {
+    badMonthCode('M2.');
+    badMonthCode('M.9L');
+    badMonthCode('M0.L');
+  });
+  it('no leading space', () => {
+    badMonthCode('M 5');
+    badMonthCode('M 9L');
+  });
+  it('not a number', () => {
+    badMonthCode('M__');
+    badMonthCode('MffL');
+  });
+  it('wrong leading character', () => {
+    badMonthCode('m11');
+    badMonthCode('N11L');
+  });
+  it('missing leading character', () => {
+    badMonthCode('12');
+    badMonthCode('03L');
+  });
+  it('wrong leap signifier', () => {
+    badMonthCode('M06l');
+    badMonthCode('M06T');
+  });
+  it('junk at end of string', () => badMonthCode('M04L+'));
+  it('wrong primitive type', () => {
+    [true, 3, Symbol('M01'), 7n].forEach((wrongType) => {
+      throws(() => ParseMonthCode(wrongType), TypeError, typeof wrongType);
+    });
+  });
+  it('wrong toString', () => {
+    throws(() => ParseMonthCode({}), RangeError);
+  });
+});
+
+describe('CreateMonthCode', () => {
+  it('all Gregorian month codes', () => {
+    ['M01', 'M02', 'M03', 'M04', 'M05', 'M06', 'M07', 'M08', 'M09', 'M10', 'M11', 'M12'].forEach((code, ix) => {
+      equal(CreateMonthCode(ix + 1, false), code);
+    });
+  });
+  it('Intercalary month 13', () => equal(CreateMonthCode(13, false), 'M13'));
+  it('all Chinese leap month codes', () => {
+    ['M01L', 'M02L', 'M03L', 'M04L', 'M05L', 'M06L', 'M07L', 'M08L', 'M09L', 'M10L', 'M11L', 'M12L'].forEach(
+      (code, ix) => {
+        equal(CreateMonthCode(ix + 1, true), code);
+      }
+    );
+  });
+  it('M00L (valid but does not occur in currently supported calendars)', () => equal(CreateMonthCode(0, true), 'M00L'));
+  it('various other month codes that do not occur in currently supported calendars', () => {
+    const tests = [
+      [14, false, 'M14'],
+      [13, true, 'M13L'],
+      [99, false, 'M99'],
+      [99, true, 'M99L'],
+      [42, false, 'M42'],
+      [57, true, 'M57L']
+    ];
+    for (const [monthNumber, isLeapMonth, code] of tests) {
+      equal(CreateMonthCode(monthNumber, isLeapMonth), code);
+    }
+  });
+});