@js-joda/core 4.1.0 → 4.3.1

package/src/ZoneId.js

@@ -4,12 +4,12 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {abstractMethodFail} from './assert';
-import {DateTimeException} from './errors';
+import { abstractMethodFail } from './assert';
+import { DateTimeException } from './errors';
 
-import {StringUtil} from './StringUtil';
+import { StringUtil } from './StringUtil';
 
-import {Instant} from './Instant';
+import { Instant } from './Instant';
 
 export class ZoneId {
     /**
@@ -80,7 +80,7 @@ export class ZoneId {
      */
     static of(zoneId) {
         // Find implementation at {@link ZoneIdFactory}
-        throw new DateTimeException(`not supported operation${  zoneId}`);
+        throw new DateTimeException(`not supported operation${zoneId}`);
     }
 
     /**
@@ -98,7 +98,7 @@ export class ZoneId {
      */
     static ofOffset(prefix, offset) {
         // Find implementation at {@link ZoneIdFactory}
-        throw new DateTimeException(`not supported operation${  prefix  }${offset}`);
+        throw new DateTimeException(`not supported operation${prefix}${offset}`);
     }
 
 
@@ -120,7 +120,7 @@ export class ZoneId {
      */
     static from(temporal) {
         // Find implementation at {@link ZoneIdFactory}
-        throw new DateTimeException(`not supported operation${  temporal}`);
+        throw new DateTimeException(`not supported operation${temporal}`);
     }
 
     //-----------------------------------------------------------------------

package/src/ZoneIdFactory.js

@@ -4,17 +4,17 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from './assert';
-import {DateTimeException, IllegalArgumentException} from './errors';
-import {StringUtil} from './StringUtil';
+import { requireNonNull } from './assert';
+import { DateTimeException, IllegalArgumentException } from './errors';
+import { StringUtil } from './StringUtil';
 
-import {ZoneOffset} from './ZoneOffset';
-import {ZoneRegion} from './ZoneRegion';
-import {ZoneId} from './ZoneId';
+import { ZoneOffset } from './ZoneOffset';
+import { ZoneRegion } from './ZoneRegion';
+import { ZoneId } from './ZoneId';
 
-import {TemporalQueries} from './temporal/TemporalQueries';
-import {SystemDefaultZoneId} from './zone/SystemDefaultZoneId';
-import {ZoneRulesProvider} from './zone/ZoneRulesProvider';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { SystemDefaultZoneId } from './zone/SystemDefaultZoneId';
+import { ZoneRulesProvider } from './zone/ZoneRulesProvider';
 
 /**
  * @see {@link ZoneId}
@@ -96,7 +96,7 @@ export class ZoneIdFactory {
             return ZoneOffset.UTC;
         }
         if (zoneId.length === 1) {
-            throw new DateTimeException(`Invalid zone: ${  zoneId}`);
+            throw new DateTimeException(`Invalid zone: ${zoneId}`);
         }
         if (StringUtil.startsWith(zoneId, '+') || StringUtil.startsWith(zoneId, '-')) {
             return ZoneOffset.of(zoneId);
@@ -117,7 +117,7 @@ export class ZoneIdFactory {
             if (offset.totalSeconds() === 0) {
                 return new ZoneRegion('UT', offset.rules());
             }
-            return new ZoneRegion(`UT${  offset.id()}`, offset.rules());
+            return new ZoneRegion(`UT${offset.id()}`, offset.rules());
         }
         // javascript special case
         if(zoneId === 'SYSTEM'){
@@ -151,7 +151,7 @@ export class ZoneIdFactory {
             }
             return new ZoneRegion(prefix + offset.id(), offset.rules());
         }
-        throw new IllegalArgumentException(`Invalid prefix, must be GMT, UTC or UT: ${  prefix}`);
+        throw new IllegalArgumentException(`Invalid prefix, must be GMT, UTC or UT: ${prefix}`);
     }
 
 
@@ -176,7 +176,7 @@ export class ZoneIdFactory {
         const obj = temporal.query(TemporalQueries.zone());
         if (obj == null) {
             throw new DateTimeException(`Unable to obtain ZoneId from TemporalAccessor: ${ 
-                temporal  }, type ${  temporal.constructor != null ? temporal.constructor.name : ''}`);
+                temporal}, type ${temporal.constructor != null ? temporal.constructor.name : ''}`);
         }
         return obj;
     }

package/src/ZoneOffset.js

@@ -4,17 +4,17 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from './assert';
-import {DateTimeException} from './errors';
-import {MathUtil} from './MathUtil';
+import { requireNonNull } from './assert';
+import { DateTimeException } from './errors';
+import { MathUtil } from './MathUtil';
 
-import {LocalTime} from './LocalTime';
-import {ZoneId} from './ZoneId';
+import { LocalTime } from './LocalTime';
+import { ZoneId } from './ZoneId';
 
-import {ChronoField} from './temporal/ChronoField';
-import {TemporalQueries} from './temporal/TemporalQueries';
+import { ChronoField } from './temporal/ChronoField';
+import { TemporalQueries } from './temporal/TemporalQueries';
 
-import {ZoneRules} from './zone/ZoneRules';
+import { ZoneRules } from './zone/ZoneRules';
 
 const SECONDS_CACHE = {};
 const ID_CACHE = {};
@@ -74,9 +74,9 @@ export class ZoneOffset extends ZoneId {
             const absTotalSeconds = Math.abs(totalSeconds);
             const absHours = MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_HOUR);
             const absMinutes = MathUtil.intMod(MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE), LocalTime.MINUTES_PER_HOUR);
-            let buf = `${  totalSeconds < 0 ? '-' : '+'
-            }${absHours < 10 ? '0' : ''  }${absHours
-            }${absMinutes < 10 ? ':0' : ':'  }${absMinutes}`;
+            let buf = `${totalSeconds < 0 ? '-' : '+'
+            }${absHours < 10 ? '0' : ''}${absHours
+            }${absMinutes < 10 ? ':0' : ':'}${absMinutes}`;
             const absSeconds = MathUtil.intMod(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE);
             if (absSeconds !== 0) {
                 buf += (absSeconds < 10 ? ':0' : ':') + (absSeconds);
@@ -106,7 +106,7 @@ export class ZoneOffset extends ZoneId {
      */
     static _validate(hours, minutes, seconds) {
         if (hours < -18 || hours > 18) {
-            throw new DateTimeException(`Zone offset hours not in valid range: value ${  hours 
+            throw new DateTimeException(`Zone offset hours not in valid range: value ${hours 
             } is not in the range -18 to 18`);
         }
         if (hours > 0) {
@@ -122,11 +122,11 @@ export class ZoneOffset extends ZoneId {
         }
         if (Math.abs(minutes) > 59) {
             throw new DateTimeException(`Zone offset minutes not in valid range: abs(value) ${ 
-                Math.abs(minutes)  } is not in the range 0 to 59`);
+                Math.abs(minutes)} is not in the range 0 to 59`);
         }
         if (Math.abs(seconds) > 59) {
             throw new DateTimeException(`Zone offset seconds not in valid range: abs(value) ${ 
-                Math.abs(seconds)  } is not in the range 0 to 59`);
+                Math.abs(seconds)} is not in the range 0 to 59`);
         }
         if (Math.abs(hours) === 18 && (Math.abs(minutes) > 0 || Math.abs(seconds) > 0)) {
             throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');
@@ -176,7 +176,7 @@ export class ZoneOffset extends ZoneId {
         let hours, minutes, seconds;
         switch (offsetId.length) {
             case 2:
-                offsetId = `${offsetId[0]  }0${  offsetId[1]}`;  // fallthru
+                offsetId = `${offsetId[0]}0${offsetId[1]}`;  // fallthru
             // eslint-disable-next-line no-fallthrough
             case 3:
                 hours = ZoneOffset._parseNumber(offsetId, 1, false);
@@ -204,11 +204,11 @@ export class ZoneOffset extends ZoneId {
                 seconds = ZoneOffset._parseNumber(offsetId, 7, true);
                 break;
             default:
-                throw new DateTimeException(`Invalid ID for ZoneOffset, invalid format: ${  offsetId}`);
+                throw new DateTimeException(`Invalid ID for ZoneOffset, invalid format: ${offsetId}`);
         }
         const first = offsetId[0];
         if (first !== '+' && first !== '-') {
-            throw new DateTimeException(`Invalid ID for ZoneOffset, plus/minus not found when expected: ${  offsetId}`);
+            throw new DateTimeException(`Invalid ID for ZoneOffset, plus/minus not found when expected: ${offsetId}`);
         }
         if (first === '-') {
             return ZoneOffset.ofHoursMinutesSeconds(-hours, -minutes, -seconds);
@@ -227,12 +227,12 @@ export class ZoneOffset extends ZoneId {
      */
     static _parseNumber(offsetId, pos, precededByColon) {
         if (precededByColon && offsetId[pos - 1] !== ':') {
-            throw new DateTimeException(`Invalid ID for ZoneOffset, colon not found when expected: ${  offsetId}`);
+            throw new DateTimeException(`Invalid ID for ZoneOffset, colon not found when expected: ${offsetId}`);
         }
         const ch1 = offsetId[pos];
         const ch2 = offsetId[pos + 1];
         if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
-            throw new DateTimeException(`Invalid ID for ZoneOffset, non numeric characters found: ${  offsetId}`);
+            throw new DateTimeException(`Invalid ID for ZoneOffset, non numeric characters found: ${offsetId}`);
         }
         return (ch1.charCodeAt(0) - 48) * 10 + (ch2.charCodeAt(0) - 48);
     }
@@ -362,7 +362,7 @@ export class ZoneOffset extends ZoneId {
         if (field === ChronoField.OFFSET_SECONDS) {
             return this._totalSeconds;
         } else if (field instanceof ChronoField) {
-            throw new DateTimeException(`Unsupported field: ${  field}`);
+            throw new DateTimeException(`Unsupported field: ${field}`);
         }
         return field.getFrom(this);
     }

package/src/ZoneRegion.js

@@ -5,8 +5,8 @@
  */
 
 
-import {ZoneId} from './ZoneId';
-import {ZoneRulesProvider} from './zone/ZoneRulesProvider';
+import { ZoneId } from './ZoneId';
+import { ZoneRulesProvider } from './zone/ZoneRulesProvider';
 
 /**
  * A geographical region where the same time-zone rules apply.

package/src/ZonedDateTime.js

@@ -4,25 +4,25 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from './assert';
-import {DateTimeException, IllegalArgumentException} from './errors';
-import {MathUtil} from './MathUtil';
-
-import {Clock} from './Clock';
-import {Instant} from './Instant';
-import {LocalDate} from './LocalDate';
-import {LocalDateTime} from './LocalDateTime';
-import {LocalTime} from './LocalTime';
-import {OffsetDateTime} from './OffsetDateTime';
-import {ZoneId} from './ZoneId';
-import {ZoneOffset} from './ZoneOffset';
-
-import {ChronoZonedDateTime} from './chrono/ChronoZonedDateTime';
-import {DateTimeFormatter} from './format/DateTimeFormatter';
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {createTemporalQuery} from './temporal/TemporalQuery';
-import {TemporalQueries} from './temporal/TemporalQueries';
+import { requireNonNull } from './assert';
+import { DateTimeException, IllegalArgumentException } from './errors';
+import { MathUtil } from './MathUtil';
+
+import { Clock } from './Clock';
+import { Instant } from './Instant';
+import { LocalDate } from './LocalDate';
+import { LocalDateTime } from './LocalDateTime';
+import { LocalTime } from './LocalTime';
+import { OffsetDateTime } from './OffsetDateTime';
+import { ZoneId } from './ZoneId';
+import { ZoneOffset } from './ZoneOffset';
+
+import { ChronoZonedDateTime } from './chrono/ChronoZonedDateTime';
+import { DateTimeFormatter } from './format/DateTimeFormatter';
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { createTemporalQuery } from './temporal/TemporalQuery';
+import { TemporalQueries } from './temporal/TemporalQueries';
 
 /**
  * A date-time with a time-zone in the ISO-8601 calendar system,
@@ -378,12 +378,12 @@ export class ZonedDateTime extends ChronoZonedDateTime {
             if (trans != null && trans.isGap()) {
                 // error message says daylight savings for simplicity
                 // even though there are other kinds of gaps
-                throw new DateTimeException(`LocalDateTime ${  localDateTime 
-                } does not exist in zone ${  zone 
+                throw new DateTimeException(`LocalDateTime ${localDateTime 
+                } does not exist in zone ${zone 
                 } due to a gap in the local time-line, typically caused by daylight savings`);
             }
-            throw new DateTimeException(`ZoneOffset "${  offset  }" is not valid for LocalDateTime "${ 
-                localDateTime  }" in zone "${  zone  }"`);
+            throw new DateTimeException(`ZoneOffset "${offset}" is not valid for LocalDateTime "${ 
+                localDateTime}" in zone "${zone}"`);
         }
         return new ZonedDateTime(localDateTime, offset, zone);
     }
@@ -1931,7 +1931,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
     toString() {
         let str = this._dateTime.toString() + this._offset.toString();
         if (this._offset !== this._zone) {
-            str += `[${  this._zone.toString()  }]`;
+            str += `[${this._zone.toString()}]`;
         }
         return str;
     }

package/src/_init.js

@@ -3,31 +3,31 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {_init as ZoneOffsetInit} from './ZoneOffset';
-import {_init as DayOfWeekInit} from './DayOfWeek';
-import {_init as DurationInit} from './Duration';
-import {_init as InstantInit} from './Instant';
-import {_init as LocalDateInit} from './LocalDate';
-import {_init as LocalTimeInit} from './LocalTime';
-import {_init as LocalDateTimeInit} from './LocalDateTime';
-import {_init as MonthInit} from './Month';
-import {_init as MonthDayInit} from './MonthDay';
-import {_init as OffsetDateTimeInit} from './OffsetDateTime';
-import {_init as OffsetTimeInit} from './OffsetTime';
-import {_init as PeriodInit} from './Period';
-import {_init as YearInit} from './Year';
-import {_init as YearConstantsInit} from './YearConstants';
-import {_init as YearMonthInit} from './YearMonth';
-import {_init as ZonedDateTimeInit} from './ZonedDateTime';
-import {_init as IsoChronologyInit} from './chrono/IsoChronology';
-import {_init as DateTimeFormatterInit} from './format/DateTimeFormatter';
-import {_init as ChronoFieldInit} from './temporal/ChronoField';
-import {_init as ChronoUnitInit} from './temporal/ChronoUnit';
-import {_init as IsoFieldsInit} from './temporal/IsoFields';
-import {_init as DateTimeFormatterBuilderInit} from './format/DateTimeFormatterBuilder';
+import { _init as ZoneOffsetInit } from './ZoneOffset';
+import { _init as DayOfWeekInit } from './DayOfWeek';
+import { _init as DurationInit } from './Duration';
+import { _init as InstantInit } from './Instant';
+import { _init as LocalDateInit } from './LocalDate';
+import { _init as LocalTimeInit } from './LocalTime';
+import { _init as LocalDateTimeInit } from './LocalDateTime';
+import { _init as MonthInit } from './Month';
+import { _init as MonthDayInit } from './MonthDay';
+import { _init as OffsetDateTimeInit } from './OffsetDateTime';
+import { _init as OffsetTimeInit } from './OffsetTime';
+import { _init as PeriodInit } from './Period';
+import { _init as YearInit } from './Year';
+import { _init as YearConstantsInit } from './YearConstants';
+import { _init as YearMonthInit } from './YearMonth';
+import { _init as ZonedDateTimeInit } from './ZonedDateTime';
+import { _init as IsoChronologyInit } from './chrono/IsoChronology';
+import { _init as DateTimeFormatterInit } from './format/DateTimeFormatter';
+import { _init as ChronoFieldInit } from './temporal/ChronoField';
+import { _init as ChronoUnitInit } from './temporal/ChronoUnit';
+import { _init as IsoFieldsInit } from './temporal/IsoFields';
+import { _init as DateTimeFormatterBuilderInit } from './format/DateTimeFormatterBuilder';
 
-import {_init as TemporalQueriesInit} from './temporal/TemporalQueriesFactory';
-import {_init as ZoneIdInit} from './ZoneIdFactory';
+import { _init as TemporalQueriesInit } from './temporal/TemporalQueriesFactory';
+import { _init as ZoneIdInit } from './ZoneIdFactory';
 
 let isInit = false;
 

package/src/assert.js

@@ -2,7 +2,7 @@
  * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
-import {NullPointerException, IllegalArgumentException} from './errors';
+import { NullPointerException, IllegalArgumentException } from './errors';
 
 /**
  * @private
@@ -30,7 +30,7 @@ export function assert(assertion, msg, error) {
  */
 export function requireNonNull(value, parameterName) {
     if (value == null) {
-        throw new NullPointerException(`${parameterName  } must not be null`);
+        throw new NullPointerException(`${parameterName} must not be null`);
     }
     return value;
 }
@@ -45,7 +45,7 @@ export function requireNonNull(value, parameterName) {
  */
 export function requireInstance(value, _class, parameterName) {
     if (!(value instanceof _class)) {
-        throw new IllegalArgumentException(`${parameterName  } must be an instance of ${  _class.name ? _class.name : _class  }${value && value.constructor && value.constructor.name ? `, but is ${  value.constructor.name}` : ''}`);
+        throw new IllegalArgumentException(`${parameterName} must be an instance of ${_class.name ? _class.name : _class}${value && value.constructor && value.constructor.name ? `, but is ${value.constructor.name}` : ''}`);
     }
     return value;
 }
@@ -56,5 +56,5 @@ export function requireInstance(value, _class, parameterName) {
  * @param methodName
  */
 export function abstractMethodFail(methodName){
-    throw new TypeError(`abstract method "${  methodName  }" is not implemented`);
+    throw new TypeError(`abstract method "${methodName}" is not implemented`);
 }

package/src/chrono/ChronoLocalDate.js

@@ -4,15 +4,15 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull, requireInstance} from '../assert';
+import { requireNonNull, requireInstance } from '../assert';
 
-import {ChronoField} from '../temporal/ChronoField';
-import {ChronoUnit} from '../temporal/ChronoUnit';
-import {DateTimeFormatter} from '../format/DateTimeFormatter';
-import {TemporalQueries} from '../temporal/TemporalQueries';
-import {Temporal} from '../temporal/Temporal';
+import { ChronoField } from '../temporal/ChronoField';
+import { ChronoUnit } from '../temporal/ChronoUnit';
+import { DateTimeFormatter } from '../format/DateTimeFormatter';
+import { TemporalQueries } from '../temporal/TemporalQueries';
+import { Temporal } from '../temporal/Temporal';
 
-import {LocalDate} from '../LocalDate';
+import { LocalDate } from '../LocalDate';
 
 /**
  * A date without time-of-day or time-zone in an arbitrary chronology, intended

package/src/chrono/ChronoLocalDateTime.js

@@ -4,16 +4,16 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull, requireInstance} from '../assert';
-import {MathUtil} from '../MathUtil';
+import { requireNonNull, requireInstance } from '../assert';
+import { MathUtil } from '../MathUtil';
 
-import {LocalDate} from '../LocalDate';
-import {Instant} from '../Instant';
-import {ZoneOffset} from '../ZoneOffset';
-import {ChronoUnit} from '../temporal/ChronoUnit';
-import {ChronoField} from '../temporal/ChronoField';
-import {Temporal} from '../temporal/Temporal';
-import {TemporalQueries} from '../temporal/TemporalQueries';
+import { LocalDate } from '../LocalDate';
+import { Instant } from '../Instant';
+import { ZoneOffset } from '../ZoneOffset';
+import { ChronoUnit } from '../temporal/ChronoUnit';
+import { ChronoField } from '../temporal/ChronoField';
+import { Temporal } from '../temporal/Temporal';
+import { TemporalQueries } from '../temporal/TemporalQueries';
 
 /**
  * A date-time without a time-zone in an arbitrary chronology, intended

package/src/chrono/ChronoZonedDateTime.js

@@ -4,14 +4,14 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from '../assert';
-import {Instant} from '../Instant';
-import {LocalDate} from '../LocalDate';
-import {MathUtil} from '../MathUtil';
+import { requireNonNull } from '../assert';
+import { Instant } from '../Instant';
+import { LocalDate } from '../LocalDate';
+import { MathUtil } from '../MathUtil';
 
-import {ChronoUnit} from '../temporal/ChronoUnit';
-import {Temporal} from '../temporal/Temporal';
-import {TemporalQueries} from '../temporal/TemporalQueries';
+import { ChronoUnit } from '../temporal/ChronoUnit';
+import { Temporal } from '../temporal/Temporal';
+import { TemporalQueries } from '../temporal/TemporalQueries';
 
 export class ChronoZonedDateTime extends Temporal {
     query(query) {

package/src/chrono/IsoChronology.js

@@ -4,19 +4,19 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {Enum} from '../Enum';
-import {requireNonNull} from '../assert';
-import {DateTimeException} from '../errors';
-import {MathUtil} from '../MathUtil';
+import { Enum } from '../Enum';
+import { requireNonNull } from '../assert';
+import { DateTimeException } from '../errors';
+import { MathUtil } from '../MathUtil';
 
-import {DayOfWeek} from '../DayOfWeek';
-import {LocalDate} from '../LocalDate';
-import {Month} from '../Month';
-import {Year} from '../Year';
+import { DayOfWeek } from '../DayOfWeek';
+import { LocalDate } from '../LocalDate';
+import { Month } from '../Month';
+import { Year } from '../Year';
 
-import {ChronoField} from '../temporal/ChronoField';
-import {ResolverStyle} from '../format/ResolverStyle';
-import {TemporalAdjusters} from '../temporal/TemporalAdjusters';
+import { ChronoField } from '../temporal/ChronoField';
+import { ResolverStyle } from '../format/ResolverStyle';
+import { TemporalAdjusters } from '../temporal/TemporalAdjusters';
 
 export class IsoChronology extends Enum{
     /**
@@ -56,7 +56,7 @@ export class IsoChronology extends Enum{
         requireNonNull(field, 'field');
         const current = fieldValues.get(field);
         if (current != null && current !== value) {
-            throw new DateTimeException(`Invalid state, field: ${  field  } ${  current  } conflicts with ${  field  } ${  value}`);
+            throw new DateTimeException(`Invalid state, field: ${field} ${current} conflicts with ${field} ${value}`);
         }
         fieldValues.put(field, value);
     }
@@ -102,7 +102,7 @@ export class IsoChronology extends Enum{
             } else if (era === 0) {
                 this._updateResolveMap(fieldValues, ChronoField.YEAR, MathUtil.safeSubtract(1, yoeLong));
             } else {
-                throw new DateTimeException(`Invalid value for era: ${  era}`);
+                throw new DateTimeException(`Invalid value for era: ${era}`);
             }
         } else if (fieldValues.containsKey(ChronoField.ERA)) {
             ChronoField.ERA.checkValidValue(fieldValues.get(ChronoField.ERA));  // always validated

package/src/convert.js

@@ -3,13 +3,13 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {IllegalArgumentException} from './errors';
+import { IllegalArgumentException } from './errors';
 
-import {LocalDate} from './LocalDate';
-import {LocalDateTime} from './LocalDateTime';
-import {ZonedDateTime} from './ZonedDateTime';
-import {ZoneId} from './ZoneId';
-import {Instant} from './Instant';
+import { LocalDate } from './LocalDate';
+import { LocalDateTime } from './LocalDateTime';
+import { ZonedDateTime } from './ZonedDateTime';
+import { ZoneId } from './ZoneId';
+import { Instant } from './Instant';
 
 class ToNativeJsConverter {
     /**
@@ -36,7 +36,7 @@ class ToNativeJsConverter {
                 zonedDateTime = temporal.withZoneSameInstant(zone);
             }
         } else {
-            throw new IllegalArgumentException(`unsupported instance for convert operation:${  temporal}`);
+            throw new IllegalArgumentException(`unsupported instance for convert operation:${temporal}`);
         }
 
         this.instant = zonedDateTime.toInstant();

package/src/errors.js

@@ -33,16 +33,16 @@ export const NullPointerException = createErrorType('NullPointerException');
 function messageWithCause(message, cause = null) {
     let msg = message || this.name;
     if (cause !== null && cause instanceof Error) {
-        msg += `\n-------\nCaused by: ${  cause.stack  }\n-------\n`;
+        msg += `\n-------\nCaused by: ${cause.stack}\n-------\n`;
     }
     this.message = msg;
 }
 
 function messageForDateTimeParseException(message, text = '', index = 0, cause = null) {
     let msg = message || this.name;
-    msg += `: ${  text  }, at index: ${  index}`;
+    msg += `: ${text}, at index: ${index}`;
     if (cause !== null && cause instanceof Error) {
-        msg += `\n-------\nCaused by: ${  cause.stack  }\n-------\n`;
+        msg += `\n-------\nCaused by: ${cause.stack}\n-------\n`;
     }
     this.message = msg;
     this.parsedString = () => {

package/src/format/DateTimeBuilder.js

@@ -4,24 +4,24 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from '../assert';
-import {DateTimeException} from '../errors';
-import {MathUtil} from '../MathUtil';
+import { requireNonNull } from '../assert';
+import { DateTimeException } from '../errors';
+import { MathUtil } from '../MathUtil';
 
-import {EnumMap} from './EnumMap';
-import {ResolverStyle} from './ResolverStyle';
+import { EnumMap } from './EnumMap';
+import { ResolverStyle } from './ResolverStyle';
 
-import {IsoChronology} from '../chrono/IsoChronology';
-import {ChronoLocalDate} from '../chrono/ChronoLocalDate';
-import {ChronoField} from '../temporal/ChronoField';
-import {TemporalAccessor} from '../temporal/TemporalAccessor';
-import {TemporalQueries} from '../temporal/TemporalQueries';
+import { IsoChronology } from '../chrono/IsoChronology';
+import { ChronoLocalDate } from '../chrono/ChronoLocalDate';
+import { ChronoField } from '../temporal/ChronoField';
+import { TemporalAccessor } from '../temporal/TemporalAccessor';
+import { TemporalQueries } from '../temporal/TemporalQueries';
 
-import {LocalTime} from '../LocalTime';
-import {LocalDate} from '../LocalDate';
-import {Period} from '../Period';
+import { LocalTime } from '../LocalTime';
+import { LocalDate } from '../LocalDate';
+import { Period } from '../Period';
 
-import {ZoneOffset} from '../ZoneOffset';
+import { ZoneOffset } from '../ZoneOffset';
 
 /**
  * Builder that can holds date and time fields and related date and time objects.
@@ -114,7 +114,7 @@ export class DateTimeBuilder extends TemporalAccessor {
         requireNonNull(field, 'field');
         const old = this.getFieldValue0(field);  // check first for better error message
         if (old != null && old !== value) {
-            throw new DateTimeException(`Conflict found: ${  field  } ${  old  } differs from ${  field  } ${  value  }: ${  this}`);
+            throw new DateTimeException(`Conflict found: ${field} ${old} differs from ${field} ${value}: ${this}`);
         }
         return this._putFieldValue0(field, value);
     }
@@ -205,7 +205,7 @@ export class DateTimeBuilder extends TemporalAccessor {
                             }
                             const val2 = this.fieldValues.get(field);
                             if (val1 !== val2) {
-                                throw new DateTimeException(`Conflict found: Field ${  field  } ${  val1  } differs from ${  field  } ${  val2  } derived from ${  date}`);
+                                throw new DateTimeException(`Conflict found: Field ${field} ${val1} differs from ${field} ${val2} derived from ${date}`);
                             }
                         }
                     }
@@ -503,7 +503,7 @@ export class DateTimeBuilder extends TemporalAccessor {
             if (this.time != null && this.time.isSupported(field)) {
                 return this.time.getLong(field);
             }
-            throw new DateTimeException(`Field not found: ${  field}`);
+            throw new DateTimeException(`Field not found: ${field}`);
         }
         return value;
     }