@js-joda/core 6.2.0 → 6.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@js-joda/core",
-  "version": "6.2.0",
+  "version": "6.3.1",
   "description": "a date and time library for javascript",
   "repository": {
     "type": "git",
@@ -47,5 +47,5 @@
     "sourceMap": false,
     "instrument": false
   },
-  "gitHead": "bb36ea96b26ee93408068c8ad8ebe8b094e96a10"
+  "gitHead": "109fb8287af88f6cbc00cf7982201e1b999aa04e"
 }

package/src/Duration.js

@@ -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));
     }
 
     //-----------------------------------------------------------------------
@@ -1089,6 +1112,21 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
     }
 
     //-----------------------------------------------------------------------
+    /**
+     * Extracts the number of days in the duration.
+     *
+     * This returns the total number of days in the duration by dividing the
+     * number of seconds by 86400.
+     * This is based on the standard definition of a day as 24 hours.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @return {number} the number of days in the duration, may be negative
+     */
+    toDaysPart() {
+        return MathUtil.intDiv(this._seconds, LocalTime.SECONDS_PER_DAY);
+    }
+
     /**
      * Extracts the number of hours part in the duration.
      *
@@ -1151,6 +1189,22 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
         return MathUtil.intDiv(this._nanos, 1000000);
     }
 
+    /**
+     * Get the nanoseconds part within seconds of the duration.
+     *
+     * The length of the duration is stored using two fields - seconds and nanoseconds.
+     * The nanoseconds part is a value from 0 to 999,999,999 that is an adjustment to
+     * the length in seconds.
+     * The total duration is defined by calling {@link Duration.nano} and {@link Duration.seconds}.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @return {number} the nanoseconds within the second part of the length of the duration, from 0 to 999,999,999
+     */
+    toNanosPart() {
+        return this._nanos;
+    }
+
     //-----------------------------------------------------------------------
     /**
      * Compares this duration to the specified {@link Duration}.
@@ -1277,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/Instant.js

@@ -916,6 +916,12 @@ export class Instant extends Temporal {
      * @throws ArithmeticException if numeric overflow occurs
      */
     toEpochMilli() {
+        if (this._seconds < 0 && this._nanos > 0) {
+            // avoid an overflow of seconds * 1000 for instants close to the minimum epoch milli
+            const millis = MathUtil.safeMultiply(this._seconds + 1, 1000);
+            const adjustment = MathUtil.intDiv(this._nanos, NANOS_PER_MILLI) - 1000;
+            return MathUtil.safeAdd(millis, adjustment);
+        }
         const millis = MathUtil.safeMultiply(this._seconds, 1000);
         return millis + MathUtil.intDiv(this._nanos, NANOS_PER_MILLI);
     }

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/MonthDay.js

@@ -25,7 +25,7 @@ import { ZoneId } from './ZoneId';
  * A month-day in the ISO-8601 calendar system, such as `--12-03`.
  *
  * {@link MonthDay} is an immutable date-time object that represents the combination
- * of a year and month. Any field that can be derived from a month and day, such as
+ * of a month and day. Any field that can be derived from a month and day, such as
  * quarter-of-year, can be obtained.
  *
  * This class does not store or represent a year, time or time-zone.

package/src/ZonedDateTime.js

@@ -319,7 +319,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      *
      * Converting an instant to a zoned date-time is simple as there is only one valid
      * offset for each instant. If the valid offset is different to the offset specified,
-     * the the date-time and offset of the zoned date-time will differ from those specified.
+     * the date-time and offset of the zoned date-time will differ from those specified.
      *
      * If the {@link ZoneId} to be used is a {@link ZoneOffset}, this method is equivalent
      * to {@link of}.

package/src/format/DateTimeBuilder.js

@@ -13,15 +13,17 @@ 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';
 
+import { Instant } from '../Instant';
 import { LocalTime } from '../LocalTime';
 import { LocalDate } from '../LocalDate';
 import { Period } from '../Period';
 
+import { ZonedDateTime } from '../ZonedDateTime';
 import { ZoneOffset } from '../ZoneOffset';
 
 /**
@@ -146,46 +148,92 @@ export class DateTimeBuilder extends TemporalAccessor {
             this.fieldValues.retainAll(resolverFields);
         }
         // handle standard fields
-        // this._mergeInstantFields();
-        if (this._resolveFields(resolverStyle)) {
-            // this._mergeInstantFields();
-        }
+        this._mergeInstantFields();
         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();
+        this._crossCheck();
         if (this.excessDays != null && this.excessDays.isZero() === false && this.date != null && this.time != null) {
             this.date = this.date.plus(this.excessDays);
             this.excessDays = Period.ZERO;
         }
-        //resolveFractional();
+        this._resolveFractional();
         this._resolveInstant();
         return this;
     }
 
     /**
-     * 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}`);
+                    }
                 }
             }
         }
@@ -470,6 +516,105 @@ export class DateTimeBuilder extends TemporalAccessor {
         }
     }
 
+    /**
+     * Converts a parsed instant-seconds into a date and a second-of-day, using the parsed zone
+     * or, if there is none, the parsed offset. Without a zone or offset, the instant-seconds
+     * are left unchanged.
+     *
+     * @private
+     */
+    _mergeInstantFields() {
+        if (this.fieldValues.containsKey(ChronoField.INSTANT_SECONDS)) {
+            if (this.zone != null) {
+                this._mergeInstantFields0(this.zone);
+            } else {
+                const offsetSecs = this.fieldValues.get(ChronoField.OFFSET_SECONDS);
+                if (offsetSecs != null) {
+                    this._mergeInstantFields0(ZoneOffset.ofTotalSeconds(offsetSecs));
+                }
+            }
+        }
+    }
+
+    /**
+     * @param {ZoneId} selectedZone
+     * @private
+     */
+    _mergeInstantFields0(selectedZone) {
+        const instant = Instant.ofEpochSecond(this.fieldValues.remove(ChronoField.INSTANT_SECONDS));
+        const zdt = ZonedDateTime.ofInstant(instant, selectedZone);
+        if (this.date == null) {
+            this._addObject(zdt.toLocalDate());
+        } else {
+            this._resolveMakeChanges(ChronoField.INSTANT_SECONDS, zdt.toLocalDate());
+        }
+        this._addFieldValue(ChronoField.SECOND_OF_DAY, zdt.toLocalTime().toSecondOfDay());
+    }
+
+    /**
+     * Checks the remaining field values against the resolved date and time, and removes the
+     * ones that match.
+     *
+     * @private
+     */
+    _crossCheck() {
+        if (this.date != null && this.time != null) {
+            this._crossCheck0(this.date.atTime(this.time));
+        } else if (this.date != null) {
+            this._crossCheck0(this.date);
+        } else if (this.time != null) {
+            this._crossCheck0(this.time);
+        }
+    }
+
+    /**
+     * @param {TemporalAccessor} temporal
+     * @private
+     */
+    _crossCheck0(temporal) {
+        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;
+                    }
+                    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);
+            }
+        }
+    }
+
+    /**
+     * Without a time, adds the fraction-of-second fields to a parsed instant-seconds,
+     * second-of-day or second-of-minute, with zero if no nano-of-second was parsed.
+     *
+     * @private
+     */
+    _resolveFractional() {
+        if (this.time == null &&
+                (this.fieldValues.containsKey(ChronoField.INSTANT_SECONDS) ||
+                    this.fieldValues.containsKey(ChronoField.SECOND_OF_DAY) ||
+                    this.fieldValues.containsKey(ChronoField.SECOND_OF_MINUTE))) {
+            if (this.fieldValues.containsKey(ChronoField.NANO_OF_SECOND)) {
+                const nos = this.fieldValues.get(ChronoField.NANO_OF_SECOND);
+                this.fieldValues.put(ChronoField.MICRO_OF_SECOND, MathUtil.intDiv(nos, 1000));
+                this.fieldValues.put(ChronoField.MILLI_OF_SECOND, MathUtil.intDiv(nos, 1000000));
+            } else {
+                this.fieldValues.put(ChronoField.NANO_OF_SECOND, 0);
+                this.fieldValues.put(ChronoField.MICRO_OF_SECOND, 0);
+                this.fieldValues.put(ChronoField.MILLI_OF_SECOND, 0);
+            }
+        }
+    }
+
     _resolveInstant() {
         if (this.date != null && this.time != null) {
             const offsetSecs = this.fieldValues.get(ChronoField.OFFSET_SECONDS);

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(', ')}}`;
+    }
 }