@js-joda/core 6.3.0 → 6.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@js-joda/core",
-  "version": "6.3.0",
+  "version": "6.3.2",
   "description": "a date and time library for javascript",
   "repository": {
     "type": "git",
@@ -31,7 +31,7 @@
     "test": "NODE_ENV=test npx mocha --timeout 5000 --require @babel/register ./test/*Test_mochaOnly.js ./test/*Test.js ./test/**/*Test.js ./test/**/**/*Test.js",
     "test-coverage": "NODE_ENV=test COVERAGE=1 npx nyc --report-dir=build/coverage --reporter=lcov --reporter html npx mocha --timeout 5000 --require @babel/register --reporter progress ./test/*Test.js ./test/**/*Test.js ./test/**/**/*Test.js",
     "test-browser": "npx karma start --reporters=dots --single-run",
-    "test-ci": "npm run build-dist && npm run test && npm run test-browser && npm run test-ts-definitions && npm run test-coverage",
+    "test-ci": "npm run build-dist && npm run lint && npm run test && npm run test-browser && npm run test-ts-definitions && npm run test-coverage",
     "test-ts-definitions": "TS_NODE_PROJECT='../../shared/ts-test-config.json' NODE_ENV=test mocha --timeout 5000 --require ts-node/register ./test/typescript_definitions/*.ts",
     "build-dist": "npx rollup -c rollup.config.js",
     "build-md-toc": "npx markdown-toc -i CheatSheet.md",
@@ -47,5 +47,5 @@
     "sourceMap": false,
     "instrument": false
   },
-  "gitHead": "8c0a3b1b555bc09fced243dac13fdf5ef9746dc7"
+  "gitHead": "2364adefa7985123ce6d17d4181bf93d0e179351"
 }

package/src/Duration.js

@@ -315,7 +315,7 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
         /**
          * The pattern for parsing.
          */
-        const PATTERN = new RegExp('([-+]?)P(?:([-+]?[0-9]+)D)?(T(?:([-+]?[0-9]+)H)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)(?:[.,]([0-9]{0,9}))?S)?)?', 'i');
+        const PATTERN = new RegExp('^([-+]?)P(?:([-+]?[0-9]+)D)?(T(?:([-+]?[0-9]+)H)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)(?:[.,]([0-9]{0,9}))?S)?)?$', 'i');
         const matches = PATTERN.exec(text);
         if (matches !== null) {
             // check for letter T but no time sections
@@ -879,8 +879,11 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
     /**
      * Returns a copy of this duration divided by the specified value.
      *
-     * In opposite to the threeten implementation the division is realized by floating point not by
-     * fixed point arithmetic. Expect floating point rounding errors for {@link Duration.dividedBy}.
+     * The result is truncated toward zero to the nanosecond, as in threeten.
+     * For an integer divisor up to `MAX_SAFE_INTEGER` (positive or negative) the division is exact.
+     * Other divisors, with a fraction or beyond `MAX_SAFE_INTEGER`, are not exactly representable
+     * or not supported by threeten; they are divided by floating point arithmetic, expect floating
+     * point rounding errors.
      *
      * @param {Number} divisor - the value to divide the duration by, positive or negative, not zero
      * @return {Duration} based on this duration divided by the specified divisor, not null
@@ -902,10 +905,30 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
             seconds += 1;
             nanos -= LocalTime.NANOS_PER_SECOND;
         }
-        const secs = MathUtil.intDiv(seconds, divisor);
-        const remainder = MathUtil.intMod(seconds, divisor);
-        const nos = MathUtil.intDiv(remainder * LocalTime.NANOS_PER_SECOND + nanos, divisor);
-        return Duration.ofSeconds(secs, nos);
+        if (!Number.isInteger(divisor) || Math.abs(divisor) > MAX_SAFE_INTEGER) {
+            const secs = MathUtil.intDiv(seconds, divisor);
+            const remainder = MathUtil.intMod(seconds, divisor);
+            const nos = MathUtil.intDiv(remainder * LocalTime.NANOS_PER_SECOND + nanos, divisor);
+            return Duration.ofSeconds(secs, nos);
+        }
+        // the remainder operator is exact for integers, so are secs and the remainder
+        const remainder = seconds % divisor;
+        const secs = MathUtil.safeZero((seconds - remainder) / divisor);
+        const sign = ((seconds < 0 || nanos < 0) ? -1 : 1) * (divisor < 0 ? -1 : 1);
+        const absRemainder = Math.abs(remainder);
+        const absNanos = Math.abs(nanos);
+        const absDivisor = Math.abs(divisor);
+        // the largest remainder for which remainder * NANOS_PER_SECOND + nanos + divisor <= MAX_SAFE_INTEGER
+        const headroom = MAX_SAFE_INTEGER - absDivisor - absNanos;
+        let quotientNanos;
+        if (headroom >= 0 && absRemainder <= MathUtil.intDiv(headroom, LocalTime.NANOS_PER_SECOND)) {
+            // the usual case, e.g. dividedBy(60): remainder * NANOS_PER_SECOND + nanos is exact
+            quotientNanos = exactFloorDiv(absRemainder * LocalTime.NANOS_PER_SECOND + absNanos, absDivisor);
+        } else {
+            // remainder * NANOS_PER_SECOND exceeds MAX_SAFE_INTEGER, divide it without computing it
+            quotientNanos = divideScaledByNanos(absRemainder, absNanos, absDivisor);
+        }
+        return Duration.ofSeconds(secs, MathUtil.safeZero(sign * quotientNanos));
     }
 
     //-----------------------------------------------------------------------
@@ -1308,6 +1331,74 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
 
 }
 
+/**
+ * `floor(value / divisor)` by floating point division, exact if `value + divisor <= MAX_SAFE_INTEGER`:
+ * with `value = q * divisor + r` and `0 <= r < divisor`, the quotient `value / divisor` is at least
+ * `1 / divisor` below `q + 1`. Rounding it up to `q + 1` would need that distance to be at most half
+ * an ulp of `q + 1`, at most `(q + 1) / 2^53`, so `divisor * (q + 1) >= 2^53`; but
+ * `divisor * (q + 1) <= value + divisor < 2^53`.
+ *
+ * @param {number} value - integer, `0 <= value`
+ * @param {number} divisor - positive integer, `value + divisor <= MAX_SAFE_INTEGER`
+ * @return {number}
+ * @private
+ */
+function exactFloorDiv(value, divisor) {
+    return Math.floor(value / divisor);
+}
+
+/**
+ * Computes `floor((remainder * NANOS_PER_SECOND + nanos) / divisor)` exactly, by long division over
+ * the nine decimal digits of `nanos`, without the intermediate values exceeding `MAX_SAFE_INTEGER`.
+ * Each step divides `rem * 10 + digit`, with `rem < divisor`, by `divisor`:
+ *
+ * * up to `MAX_SAFE_INTEGER / 11`, `rem * 10 + digit + divisor < 11 * divisor` is small enough
+ *   for {@link exactFloorDiv}
+ * * above, `rem * 10` itself may exceed `MAX_SAFE_INTEGER`; it is computed as ten additions of `rem`
+ *   modulo `divisor`, counting the wrap-arounds, so that all values stay below `divisor`
+ *
+ * @param {number} remainder - integer, `0 <= remainder < divisor`
+ * @param {number} nanos - integer, `0 <= nanos < NANOS_PER_SECOND`
+ * @param {number} divisor - positive integer, at most `MAX_SAFE_INTEGER`
+ * @return {number} the quotient, `0 <= quotient < NANOS_PER_SECOND`
+ * @private
+ */
+function divideScaledByNanos(remainder, nanos, divisor) {
+    const directLimit = MathUtil.intDiv(MAX_SAFE_INTEGER, 11);
+    let rem = remainder;
+    let quotient = 0;
+    for (let scale = 100000000; scale >= 1; scale /= 10) {
+        const digit = MathUtil.intDiv(nanos, scale) % 10;
+        let digitQuotient;
+        if (divisor <= directLimit) {
+            const value = rem * 10 + digit;
+            digitQuotient = exactFloorDiv(value, divisor);
+            rem = value - digitQuotient * divisor;
+        } else {
+            // digit < 10 < divisor, so divisor - digit and divisor - rem are positive and exact
+            let acc = 0;
+            digitQuotient = 0;
+            for (let i = 0; i < 10; i++) {
+                if (acc >= divisor - rem) {
+                    acc -= divisor - rem;
+                    digitQuotient++;
+                } else {
+                    acc += rem;
+                }
+            }
+            if (acc >= divisor - digit) {
+                acc -= divisor - digit;
+                digitQuotient++;
+            } else {
+                acc += digit;
+            }
+            rem = acc;
+        }
+        quotient = quotient * 10 + digitQuotient;
+    }
+    return quotient;
+}
+
 export function _init() {
     /**
      * Constant for a duration of zero.

package/src/LocalDate.js

@@ -178,9 +178,10 @@ export class LocalDate extends ChronoLocalDate{
      *
      * @param {number} [epochDay=0] - the Epoch Day to convert, based on the epoch 1970-01-01
      * @return {LocalDate} the local date, not null
-     * @throws {AssertionError} if the epoch days exceeds the supported date range
+     * @throws {DateTimeException} if the epoch days exceeds the supported date range
      */
     static ofEpochDay(epochDay=0) {
+        ChronoField.EPOCH_DAY.checkValidValue(epochDay);
         let adjust, adjustCycles, doyEst, yearEst, zeroDay;
         zeroDay = epochDay + DAYS_0000_TO_1970;
         zeroDay -= 60;

package/src/Period.js

@@ -18,7 +18,7 @@ import { LocalDate } from './LocalDate';
 /**
  * The pattern for parsing.
  */
-const PATTERN = /([-+]?)P(?:([-+]?[0-9]+)Y)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)W)?(?:([-+]?[0-9]+)D)?/;
+const PATTERN = /^([-+]?)P(?:([-+]?[0-9]+)Y)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)W)?(?:([-+]?[0-9]+)D)?$/i;
 
 /**
  * A date-based amount of time, such as '2 years, 3 months and 4 days'.

package/src/format/DateTimeBuilder.js

@@ -13,8 +13,8 @@ import { ResolverStyle } from './ResolverStyle';
 
 import { IsoChronology } from '../chrono/IsoChronology';
 import { ChronoLocalDate } from '../chrono/ChronoLocalDate';
+import { ChronoLocalDateTime } from '../chrono/ChronoLocalDateTime';
 import { ChronoField } from '../temporal/ChronoField';
-import { IsoFields } from '../temporal/IsoFields';
 import { TemporalAccessor } from '../temporal/TemporalAccessor';
 import { TemporalQueries } from '../temporal/TemporalQueries';
 
@@ -149,9 +149,14 @@ export class DateTimeBuilder extends TemporalAccessor {
         }
         // handle standard fields
         this._mergeInstantFields();
-        this._resolveFields(resolverStyle);
         this._mergeDate(resolverStyle);
         this._mergeTime(resolverStyle);
+        // the other fields may need fields produced by merging, e.g. YEAR from YEAR_OF_ERA
+        if (this._resolveFields(resolverStyle)) {
+            this._mergeInstantFields();
+            this._mergeDate(resolverStyle);
+            this._mergeTime(resolverStyle);
+        }
         this._resolveTimeInferZeroes(resolverStyle);
         this._crossCheck();
         if (this.excessDays != null && this.excessDays.isZero() === false && this.date != null && this.time != null) {
@@ -164,28 +169,71 @@ export class DateTimeBuilder extends TemporalAccessor {
     }
 
     /**
-     * Resolves the date fields that are not {@link ChronoField}s by delegating to their own
-     * `resolve()`, the step java.time performs generically. As parsed values are held in a
-     * name-keyed map, the ISO fields that define a `resolve()` (week-of-week-based-year and
-     * day-of-quarter) are handled here. They do not depend on one another, so one pass is
-     * sufficient. Returns whether a date was produced.
+     * Resolves the fields that are not {@link ChronoField}s, such as {@link IsoFields} or the
+     * fields of `@js-joda/locale` WeekFields, by delegating to their own `resolve()`, as
+     * java.time does. A field may resolve to a date, a time or a date-time, or replace itself
+     * by other fields (for example a localized day-of-week by {@link ChronoField.DAY_OF_WEEK}),
+     * so the fields are visited again after each change. Returns whether anything changed.
      *
      * @param {ResolverStyle} resolverStyle
      * @return {boolean}
      * @private
      */
     _resolveFields(resolverStyle) {
-        let resolved = false;
-        for (const field of [IsoFields.WEEK_OF_WEEK_BASED_YEAR, IsoFields.DAY_OF_QUARTER]) {
-            if (this.fieldValues.containsKey(field)) {
-                const date = field.resolve(this.fieldValues, this, resolverStyle);
-                if (date != null) {
-                    this._checkDate(date);
-                    resolved = true;
+        let changes = 0;
+        let changed = true;
+        while (changed && changes < 100) {
+            changed = false;
+            const fields = this.fieldValues.keys();
+            for (let i = 0; i < fields.length; i++) {
+                const field = fields[i];
+                if (field instanceof ChronoField || typeof field.resolve !== 'function') {
+                    continue;
+                }
+                const resolved = field.resolve(this.fieldValues, this, resolverStyle);
+                if (resolved != null) {
+                    if (resolved instanceof ChronoLocalDateTime) {
+                        this._resolveMakeChanges(field, resolved.toLocalDate());
+                        this._resolveMakeChanges(field, resolved.toLocalTime());
+                    } else if (resolved instanceof ChronoLocalDate || resolved instanceof LocalTime) {
+                        this._resolveMakeChanges(field, resolved);
+                    } else {
+                        throw new DateTimeException(`Unknown type: ${resolved}`);
+                    }
+                    changed = true;
+                } else if (this.fieldValues.containsKey(field) === false) {
+                    changed = true;
+                }
+                if (changed) {
+                    changes++;
+                    break; // start again, the fields have changed
                 }
             }
         }
-        return resolved;
+        if (changes === 100) {
+            throw new DateTimeException('Badly written field');
+        }
+        return changes > 0;
+    }
+
+    /**
+     * Adds a date or time resolved by a field as {@link ChronoField.EPOCH_DAY} or
+     * {@link ChronoField.NANO_OF_DAY}, to be merged with the other fields.
+     *
+     * @param {TemporalField} targetField
+     * @param {ChronoLocalDate|LocalTime} dateOrTime
+     * @private
+     */
+    _resolveMakeChanges(targetField, dateOrTime) {
+        const isDate = dateOrTime instanceof ChronoLocalDate;
+        const field = isDate ? ChronoField.EPOCH_DAY : ChronoField.NANO_OF_DAY;
+        const value = isDate ? dateOrTime.toEpochDay() : dateOrTime.toNanoOfDay();
+        const old = this.fieldValues.get(field);
+        if (old != null && old !== value) {
+            const oldDateOrTime = isDate ? LocalDate.ofEpochDay(old) : LocalTime.ofNanoOfDay(old);
+            throw new DateTimeException(`Conflict found: ${oldDateOrTime} differs from ${dateOrTime} while resolving ${targetField}`);
+        }
+        this.fieldValues.put(field, value);
     }
 
     /**
@@ -211,28 +259,26 @@ export class DateTimeBuilder extends TemporalAccessor {
      */
     _checkDate(date) {
         if (date != null) {
+            if (this.date != null && this.date.equals(date) === false) {
+                throw new DateTimeException(`Conflict found: Fields resolved to two different dates: ${this.date} ${date}`);
+            }
             this._addObject(date);
-            for (const fieldName in this.fieldValues.keySet()) {
-                const field = ChronoField.byName(fieldName);
-                if (field) {
-                    if (this.fieldValues.get(field) !== undefined) { // undefined if "removed" in EnumMap
-                        if (field.isDateBased()) {
-                            let val1;
-                            try {
-                                val1 = date.getLong(field);
-                            } catch (ex) {
-                                if (ex instanceof DateTimeException) {
-                                    continue;
-                                } else {
-                                    throw ex;
-                                }
-                            }
-                            const val2 = this.fieldValues.get(field);
-                            if (val1 !== val2) {
-                                throw new DateTimeException(`Conflict found: Field ${field} ${val1} differs from ${field} ${val2} derived from ${date}`);
-                            }
+            for (const field of this.fieldValues.keys()) {
+                if (field instanceof ChronoField && field.isDateBased()) {
+                    let val1;
+                    try {
+                        val1 = date.getLong(field);
+                    } catch (ex) {
+                        if (ex instanceof DateTimeException) {
+                            continue;
+                        } else {
+                            throw ex;
                         }
                     }
+                    const val2 = this.fieldValues.get(field);
+                    if (val1 !== val2) {
+                        throw new DateTimeException(`Conflict found: Field ${field} ${val1} differs from ${field} ${val2} derived from ${date}`);
+                    }
                 }
             }
         }
@@ -505,20 +551,6 @@ export class DateTimeBuilder extends TemporalAccessor {
         this._addFieldValue(ChronoField.SECOND_OF_DAY, zdt.toLocalTime().toSecondOfDay());
     }
 
-    /**
-     * @param {TemporalField} targetField
-     * @param {LocalDate} date
-     * @private
-     */
-    _resolveMakeChanges(targetField, date) {
-        const epochDay = date.toEpochDay();
-        const old = this.fieldValues.get(ChronoField.EPOCH_DAY);
-        this.fieldValues.put(ChronoField.EPOCH_DAY, epochDay);
-        if (old != null && old !== epochDay) {
-            throw new DateTimeException(`Conflict found: ${LocalDate.ofEpochDay(old)} differs from ${LocalDate.ofEpochDay(epochDay)} while resolving  ${targetField}`);
-        }
-    }
-
     /**
      * Checks the remaining field values against the resolved date and time, and removes the
      * ones that match.
@@ -540,25 +572,22 @@ export class DateTimeBuilder extends TemporalAccessor {
      * @private
      */
     _crossCheck0(temporal) {
-        for (const fieldName in this.fieldValues.keySet()) {
-            const field = ChronoField.byName(fieldName);
-            if (field && this.fieldValues.get(field) !== undefined) { // undefined if "removed" in EnumMap
-                if (temporal.isSupported(field)) {
-                    let temporalValue;
-                    try {
-                        temporalValue = temporal.getLong(field);
-                    } catch (ex) {
-                        if (ex instanceof DateTimeException) {
-                            continue;
-                        }
-                        throw ex;
+        for (const field of this.fieldValues.keys()) {
+            if (temporal.isSupported(field)) {
+                let temporalValue;
+                try {
+                    temporalValue = temporal.getLong(field);
+                } catch (ex) {
+                    if (ex instanceof DateTimeException) {
+                        continue;
                     }
-                    const value = this.fieldValues.get(field);
-                    if (temporalValue !== value) {
-                        throw new DateTimeException(`Cross check failed: ${field} ${temporalValue} vs ${field} ${value}`);
-                    }
-                    this.fieldValues.remove(field);
+                    throw ex;
+                }
+                const value = this.fieldValues.get(field);
+                if (temporalValue !== value) {
+                    throw new DateTimeException(`Cross check failed: ${field} ${temporalValue} vs ${field} ${value}`);
                 }
+                this.fieldValues.remove(field);
             }
         }
     }

package/src/format/EnumMap.js

@@ -4,6 +4,12 @@
  */
 
 /**
+ * A map from {@link TemporalField} to value.
+ *
+ * Fields are matched by identity, like the `HashMap` used by java.time. Entries are bucketed
+ * by `field.name()`, but fields with the same name are distinct keys: for example the
+ * `WeekBasedYear` field of `@js-joda/locale` WeekFields is not `IsoFields.WEEK_BASED_YEAR`.
+ *
  * @private
  */
 export class EnumMap {
@@ -11,20 +17,49 @@ export class EnumMap {
         this._map = {};
     }
 
+    /**
+     * @param {TemporalField} key
+     * @return {?Array<{key: TemporalField, value: *}>} the entries with the name of key, or undefined
+     * @private
+     */
+    _bucket(key){
+        const name = key.name();
+        return Object.prototype.hasOwnProperty.call(this._map, name) ? this._map[name] : undefined;
+    }
+
+    /**
+     * @param {TemporalField} key
+     * @return {?{key: TemporalField, value: *}} the entry of key, or undefined
+     * @private
+     */
+    _entry(key){
+        const bucket = this._bucket(key);
+        if (bucket != null) {
+            for (let i = 0; i < bucket.length; i++) {
+                if (bucket[i].key === key) {
+                    return bucket[i];
+                }
+            }
+        }
+        return undefined;
+    }
+
     putAll(otherMap){
-        for(const key in otherMap._map){
-            this._map[key] = otherMap._map[key];
+        const keys = otherMap.keys();
+        for (let i = 0; i < keys.length; i++) {
+            this.set(keys[i], otherMap.get(keys[i]));
         }
         return this;
     }
 
     containsKey(key){
-        // eslint-disable-next-line no-prototype-builtins
-        return (this._map.hasOwnProperty(key.name())) && (this.get(key) !== undefined);
+        const entry = this._entry(key);
+        return entry != null && entry.value !== undefined;
     }
 
     get(key) {
-        return this._map[key.name()];
+        const entry = this._entry(key);
+        return entry != null ? entry.value : undefined;
     }
 
     put(key, val) {
@@ -32,39 +67,74 @@ export class EnumMap {
     }
 
     set(key, val) {
-        this._map[key.name()] = val;
+        const entry = this._entry(key);
+        if (entry != null) {
+            entry.value = val;
+        } else {
+            const name = key.name();
+            // eslint-disable-next-line no-prototype-builtins
+            if (this._map.hasOwnProperty(name) === false) {
+                this._map[name] = [];
+            }
+            this._map[name].push({ key, value: val });
+        }
         return this;
     }
 
     retainAll(keyList){
-        const map = {};
-        for(let i=0; i<keyList.length; i++){
-            const key = keyList[i].name();
-            map[key] = this._map[key];
+        const retained = new EnumMap();
+        for (let i = 0; i < keyList.length; i++) {
+            if (this.containsKey(keyList[i])) {
+                retained.set(keyList[i], this.get(keyList[i]));
+            }
         }
-        this._map = map;
+        this._map = retained._map;
         return this;
     }
 
-    /**
-     * due to the bad performance of delete we just set the key entry to undefined.
-     *
-     * this might lead to issues with "null" entries. Calling clear in the end might solve the issue
-     * @param key
-     * @returns {*}
-     */
     remove(key){
-        const keyName = key.name();
-        const val = this._map[keyName];
-        this._map[keyName] = undefined;
-        return val;
+        const bucket = this._bucket(key);
+        if (bucket != null) {
+            for (let i = 0; i < bucket.length; i++) {
+                if (bucket[i].key === key) {
+                    const val = bucket[i].value;
+                    bucket.splice(i, 1);
+                    if (bucket.length === 0) {
+                        delete this._map[key.name()];
+                    }
+                    return val;
+                }
+            }
+        }
+        return undefined;
     }
 
-    keySet(){
-        return this._map;
+    /**
+     * Returns the fields that have a value, a snapshot that is not changed by later updates.
+     *
+     * @return {TemporalField[]}
+     */
+    keys(){
+        const keys = [];
+        for (const name in this._map) {
+            // eslint-disable-next-line no-prototype-builtins
+            if (this._map.hasOwnProperty(name)) {
+                const bucket = this._map[name];
+                for (let i = 0; i < bucket.length; i++) {
+                    if (bucket[i].value !== undefined) {
+                        keys.push(bucket[i].key);
+                    }
+                }
+            }
+        }
+        return keys;
     }
 
     clear(){
         this._map = {};
     }
+
+    toString(){
+        return `{${this.keys().map((key) => `${key}=${this.get(key)}`).join(', ')}}`;
+    }
 }

package/src/zone/SystemDefaultZoneRules.js

@@ -7,6 +7,29 @@ import { ZoneRules } from './ZoneRules';
 import { ZoneOffset } from '../ZoneOffset';
 import { DateTimeException } from '../errors';
 
+// the range of a Date in epoch millis (ECMA-262), a Date outside of it is invalid
+const MAX_DATE_EPOCH_MILLI = 8640000000000000;
+
+// the timezone offset of a Date in minutes, as Date.getTimezoneOffset(); an epoch milli outside
+// the range of a Date is clamped to it, so that far instants get the offset at the end of the range
+function timezoneOffsetInMinutes(epochMilli) {
+    const clamped = Math.max(-MAX_DATE_EPOCH_MILLI, Math.min(MAX_DATE_EPOCH_MILLI, epochMilli));
+    return new Date(clamped).getTimezoneOffset();
+}
+
+// the epoch milli of the instant, clamped to the range of a Date; Instant.toEpochMilli() would
+// overflow for instants like Instant.MAX
+function clampedEpochMilli(instant) {
+    const epochSecond = instant.epochSecond();
+    if (epochSecond > MAX_DATE_EPOCH_MILLI / 1000) {
+        return MAX_DATE_EPOCH_MILLI;
+    }
+    if (epochSecond < -MAX_DATE_EPOCH_MILLI / 1000) {
+        return -MAX_DATE_EPOCH_MILLI;
+    }
+    return instant.toEpochMilli();
+}
+
 export class SystemDefaultZoneRules extends ZoneRules {
 
     isFixedOffset(){
@@ -19,7 +42,7 @@ export class SystemDefaultZoneRules extends ZoneRules {
      * @returns {ZoneOffset}
      */
     offsetOfInstant(instant){
-        const offsetInMinutes = new Date(instant.toEpochMilli()).getTimezoneOffset();
+        const offsetInMinutes = timezoneOffsetInMinutes(clampedEpochMilli(instant));
         return ZoneOffset.ofTotalMinutes(offsetInMinutes * -1);
     }
 
@@ -29,7 +52,7 @@ export class SystemDefaultZoneRules extends ZoneRules {
      * @returns {ZoneOffset}
      */
     offsetOfEpochMilli(epochMilli){
-        const offsetInMinutes = new Date(epochMilli).getTimezoneOffset();
+        const offsetInMinutes = timezoneOffsetInMinutes(epochMilli);
         return ZoneOffset.ofTotalMinutes(offsetInMinutes * -1);
     }
 
@@ -48,9 +71,9 @@ export class SystemDefaultZoneRules extends ZoneRules {
      */
     offsetOfLocalDateTime(localDateTime){
         const epochMilli = localDateTime.toEpochSecond(ZoneOffset.UTC) * 1000;
-        const offsetInMinutesBeforePossibleTransition = new Date(epochMilli).getTimezoneOffset();
+        const offsetInMinutesBeforePossibleTransition = timezoneOffsetInMinutes(epochMilli);
         const epochMilliSystemZone = epochMilli + offsetInMinutesBeforePossibleTransition * 60000;
-        const offsetInMinutesAfterPossibleTransition = new Date(epochMilliSystemZone).getTimezoneOffset();
+        const offsetInMinutesAfterPossibleTransition = timezoneOffsetInMinutes(epochMilliSystemZone);
         return ZoneOffset.ofTotalMinutes(offsetInMinutesAfterPossibleTransition * -1);
     }