@js-joda/core 3.2.0 → 4.2.1

package/src/Period.js

@@ -4,16 +4,16 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {MathUtil} from './MathUtil';
-import {requireNonNull, requireInstance} from './assert';
-import {DateTimeException, UnsupportedTemporalTypeException, ArithmeticException, DateTimeParseException} from './errors';
+import { MathUtil } from './MathUtil';
+import { requireNonNull, requireInstance } from './assert';
+import { DateTimeException, UnsupportedTemporalTypeException, ArithmeticException, DateTimeParseException } from './errors';
 
-import {IsoChronology} from './chrono/IsoChronology';
+import { IsoChronology } from './chrono/IsoChronology';
 
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {TemporalAmount} from './temporal/TemporalAmount';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { TemporalAmount } from './temporal/TemporalAmount';
 
-import {LocalDate} from './LocalDate';
+import { LocalDate } from './LocalDate';
 
 /**
  * The pattern for parsing.
@@ -214,7 +214,7 @@ export class Period extends TemporalAmount /* extends ChronoPeriod */ {
             } else if (unit === ChronoUnit.DAYS) {
                 days = MathUtil.safeToInt(unitAmount);
             } else {
-                throw new DateTimeException('Unit must be Years, Months or Days, but was ' + unit);
+                throw new DateTimeException(`Unit must be Years, Months or Days, but was ${unit}`);
             }
         }
         return Period.create(years, months, days);
@@ -393,7 +393,7 @@ export class Period extends TemporalAmount /* extends ChronoPeriod */ {
         if (unit === ChronoUnit.DAYS) {
             return this._days;
         }
-        throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+        throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
     }
 
     //-----------------------------------------------------------------------
@@ -904,13 +904,13 @@ export class Period extends TemporalAmount /* extends ChronoPeriod */ {
         } else {
             let buf = 'P';
             if (this._years !== 0) {
-                buf += '' + this._years + 'Y';
+                buf += `${this._years}Y`;
             }
             if (this._months !== 0) {
-                buf += '' + this._months + 'M';
+                buf += `${this._months}M`;
             }
             if (this._days !== 0) {
-                buf += '' + this._days + 'D';
+                buf += `${this._days}D`;
             }
             return buf;
         }

package/src/StringUtil.js

@@ -3,7 +3,7 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {MathUtil} from './MathUtil';
+import { MathUtil } from './MathUtil';
 
 /**
  * @private

package/src/Year.js

@@ -4,30 +4,29 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {DateTimeException, UnsupportedTemporalTypeException} from './errors';
-import {requireNonNull, requireInstance} from './assert';
-import {MathUtil} from './MathUtil';
-
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {Clock} from './Clock';
-import {DateTimeFormatter} from './format/DateTimeFormatter';
-import {DateTimeFormatterBuilder} from './format/DateTimeFormatterBuilder';
-import {IsoChronology} from './chrono/IsoChronology';
-import {LocalDate} from './LocalDate';
-import {Month} from './Month';
-import {MonthDay} from './MonthDay';
-import {SignStyle} from './format/SignStyle';
-import {Temporal} from './temporal/Temporal';
-import {TemporalAccessor} from './temporal/TemporalAccessor';
-import {TemporalAmount} from './temporal/TemporalAmount';
-import {TemporalField} from './temporal/TemporalField';
-import {TemporalQueries} from './temporal/TemporalQueries';
-import {TemporalQuery, createTemporalQuery} from './temporal/TemporalQuery';
-import {TemporalUnit} from './temporal/TemporalUnit';
-import {YearConstants} from './YearConstants';
-import {YearMonth} from './YearMonth';
-import {ZoneId} from './ZoneId';
+import { DateTimeException, UnsupportedTemporalTypeException } from './errors';
+import { requireNonNull, requireInstance } from './assert';
+import { MathUtil } from './MathUtil';
+
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { Clock } from './Clock';
+import { DateTimeFormatter } from './format/DateTimeFormatter';
+import { DateTimeFormatterBuilder } from './format/DateTimeFormatterBuilder';
+import { IsoChronology } from './chrono/IsoChronology';
+import { LocalDate } from './LocalDate';
+import { Month } from './Month';
+import { MonthDay } from './MonthDay';
+import { SignStyle } from './format/SignStyle';
+import { Temporal } from './temporal/Temporal';
+import { TemporalAccessor } from './temporal/TemporalAccessor';
+import { TemporalField } from './temporal/TemporalField';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { TemporalQuery, createTemporalQuery } from './temporal/TemporalQuery';
+import { TemporalUnit } from './temporal/TemporalUnit';
+import { YearConstants } from './YearConstants';
+import { YearMonth } from './YearMonth';
+import { ZoneId } from './ZoneId';
 
 
 /**
@@ -209,8 +208,8 @@ export class Year extends Temporal {
             }*/
             return Year.of(temporal.get(ChronoField.YEAR));
         } catch (ex) {
-            throw new DateTimeException('Unable to obtain Year from TemporalAccessor: ' +
-                    temporal + ', type ' + (temporal && temporal.constructor != null ? temporal.constructor.name : ''));
+            throw new DateTimeException(`Unable to obtain Year from TemporalAccessor: ${ 
+                temporal}, type ${temporal && temporal.constructor != null ? temporal.constructor.name : ''}`);
         }
     }
     //-----------------------------------------------------------------------
@@ -372,7 +371,7 @@ export class Year extends Temporal {
         if (this.isSupported(field)) {
             return field.range();
         } else if (field instanceof ChronoField) {
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return super.range(field);
     }
@@ -434,7 +433,7 @@ export class Year extends Temporal {
                 case ChronoField.YEAR: return this._year;
                 case ChronoField.ERA: return (this._year < 1 ? 0 : 1);
             }
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.getFrom(this);
     }
@@ -464,29 +463,6 @@ export class Year extends Temporal {
 
     //-----------------------------------------------------------------------
 
-    /**
-     * Returns an adjusted copy of this year.
-     *
-     * This returns a new {@link Year}, based on this one, with the year adjusted.
-     * The adjustment takes place using the specified adjuster strategy object.
-     * Read the documentation of the adjuster to understand what adjustment will be made.
-     *
-     * The result of this method is obtained by invoking the
-     * {@link TemporalAdjuster#adjustInto} method on the
-     * specified adjuster passing `this` as the argument.
-     *
-     * This instance is immutable and unaffected by this method call.
-     *
-     * @param {TemporalAdjuster} adjuster the adjuster to use, not null
-     * @returns {Year} based on `this` with the adjustment made, not null
-     * @throws DateTimeException if the adjustment cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    withAdjuster(adjuster) {
-        requireNonNull(adjuster, 'adjuster');
-        return adjuster.adjustInto(this);
-    }
-
     /**
      * Returns a copy of this year with the specified field set to a new value.
      *
@@ -526,7 +502,7 @@ export class Year extends Temporal {
      * @throws DateTimeException if the field cannot be set
      * @throws ArithmeticException if numeric overflow occurs
      */
-    withFieldValue(field, newValue) {
+    _withField(field, newValue) {
         requireNonNull(field, 'field');
         requireInstance(field, TemporalField, 'field');
         if (field instanceof ChronoField) {
@@ -539,33 +515,11 @@ export class Year extends Temporal {
                 case ChronoField.ERA:
                     return (this.getLong(ChronoField.ERA) === newValue ? this : Year.of(1 - this._year));
             }
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.adjustInto(this, newValue);
     }
 
-    /**
-     * Returns a copy of this year with the specified period added.
-     *
-     * This method returns a new year based on this year with the specified period added.
-     * The adder is typically {@link Period} but may be any other type implementing
-     * the {@link TemporalAmount} interface.
-     * The calculation is delegated to the specified adjuster, which typically calls
-     * back to {@link plus}.
-     *
-     * This instance is immutable and unaffected by this method call.
-     *
-     * @param {TemporalAmount} amount  the amount to add, not null
-     * @return {Year} based on this year with the addition made, not null
-     * @throws DateTimeException if the addition cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    plusAmount(amount) {
-        requireNonNull(amount, 'amount');
-        requireInstance(amount, TemporalAmount, 'amount');
-        return amount.addTo(this);
-    }
-
     /**
      * @param {number} amountToAdd
      * @param {TemporalUnit} unit
@@ -573,7 +527,7 @@ export class Year extends Temporal {
      * @throws DateTimeException if the addition cannot be made
      * @throws ArithmeticException if numeric overflow occurs
      */
-    plusAmountUnit(amountToAdd, unit) {
+    _plusUnit(amountToAdd, unit) {
         requireNonNull(amountToAdd, 'amountToAdd');
         requireNonNull(unit, 'unit');
         requireInstance(unit, TemporalUnit, 'unit');
@@ -585,7 +539,7 @@ export class Year extends Temporal {
                 case ChronoUnit.MILLENNIA: return this.plusYears(MathUtil.safeMultiply(amountToAdd, 1000));
                 case ChronoUnit.ERAS: return this.with(ChronoField.ERA, MathUtil.safeAdd(this.getLong(ChronoField.ERA), amountToAdd));
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.addTo(this, amountToAdd);
     }
@@ -608,42 +562,6 @@ export class Year extends Temporal {
 
     //-----------------------------------------------------------------------
 
-    /**
-     * Returns a copy of this year with the specified period subtracted.
-     *
-     * This method returns a new year based on this year with the specified period subtracted.
-     * The subtractor is typically {@link Period} but may be any other type implementing
-     * the {@link TemporalAmount} interface.
-     * The calculation is delegated to the specified adjuster, which typically calls
-     * back to {@link minus}.
-     *
-     * This instance is immutable and unaffected by this method call.
-     *
-     * @param {TemporalAmount} amount  the amount to subtract, not null
-     * @return {Year} based on this year with the subtraction made, not null
-     * @throws DateTimeException if the subtraction cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    minusAmount(amount) {
-        requireNonNull(amount, 'amount');
-        requireInstance(amount, TemporalAmount, 'amount');
-        return amount.subtractFrom(this);
-    }
-
-    /**
-     * @param {number} amountToSubtract  the amount to subtract, not null
-     * @param {TemporalUnit} unit
-     * @return {Year} based on this year with the subtraction made, not null
-     * @throws DateTimeException if the subtraction cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    minusAmountUnit(amountToSubtract, unit) {
-        requireNonNull(amountToSubtract, 'amountToSubtract');
-        requireNonNull(unit, 'unit');
-        requireInstance(unit, TemporalUnit, 'unit');
-        return (amountToSubtract === MathUtil.MIN_SAFE_INTEGER ? this.plus(MathUtil.MAX_SAFE_INTEGER, unit).plus(1, unit) : this.plus(-amountToSubtract, unit));
-    }
-
     /**
      * Returns a copy of this year with the specified number of years subtracted.
      *
@@ -913,7 +831,7 @@ export class Year extends Temporal {
      * @return {String} a string representation of this year, not null
      */
     toString() {
-        return '' + this._year;
+        return `${this._year}`;
     }
 
     /**
@@ -992,7 +910,7 @@ export class Year extends Temporal {
                 case ChronoUnit.ERAS:
                     return end.getLong(ChronoField.ERA) - this.getLong(ChronoField.ERA);
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.between(this, end);
     }

package/src/YearMonth.js

@@ -3,28 +3,27 @@
  * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
  */
 
-import {requireNonNull, requireInstance} from './assert';
-import {DateTimeException, UnsupportedTemporalTypeException} from './errors';
-import {MathUtil} from './MathUtil';
-
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {Clock} from './Clock';
-import {DateTimeFormatterBuilder} from './format/DateTimeFormatterBuilder';
-import {IsoChronology} from './chrono/IsoChronology';
-import {LocalDate} from './LocalDate';
-import {Month} from './Month';
-import {SignStyle} from './format/SignStyle';
-import {Temporal} from './temporal/Temporal';
-import {TemporalAmount} from './temporal/TemporalAmount';
-import {TemporalField} from './temporal/TemporalField';
-import {TemporalQueries} from './temporal/TemporalQueries';
-import {TemporalQuery} from './temporal/TemporalQuery';
-import {TemporalUnit} from './temporal/TemporalUnit';
-import {createTemporalQuery} from './temporal/TemporalQuery';
-import {ValueRange} from './temporal/ValueRange';
-import {Year} from './Year';
-import {ZoneId} from './ZoneId';
+import { requireNonNull, requireInstance } from './assert';
+import { DateTimeException, UnsupportedTemporalTypeException } from './errors';
+import { MathUtil } from './MathUtil';
+
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { Clock } from './Clock';
+import { DateTimeFormatterBuilder } from './format/DateTimeFormatterBuilder';
+import { IsoChronology } from './chrono/IsoChronology';
+import { LocalDate } from './LocalDate';
+import { Month } from './Month';
+import { SignStyle } from './format/SignStyle';
+import { Temporal } from './temporal/Temporal';
+import { TemporalField } from './temporal/TemporalField';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { TemporalQuery } from './temporal/TemporalQuery';
+import { TemporalUnit } from './temporal/TemporalUnit';
+import { createTemporalQuery } from './temporal/TemporalQuery';
+import { ValueRange } from './temporal/ValueRange';
+import { Year } from './Year';
+import { ZoneId } from './ZoneId';
 
 /**
  * A year-month in the ISO-8601 calendar system, such as `2007-12`.
@@ -199,8 +198,8 @@ export class YearMonth extends Temporal {
             }*/
             return YearMonth.of(temporal.get(ChronoField.YEAR), temporal.get(ChronoField.MONTH_OF_YEAR));
         } catch (ex) {
-            throw new DateTimeException('Unable to obtain YearMonth from TemporalAccessor: ' +
-                    temporal + ', type ' + (temporal && temporal.constructor != null ? temporal.constructor.name : ''));
+            throw new DateTimeException(`Unable to obtain YearMonth from TemporalAccessor: ${ 
+                temporal}, type ${temporal && temporal.constructor != null ? temporal.constructor.name : ''}`);
         }
     }
     //-----------------------------------------------------------------------
@@ -419,7 +418,7 @@ export class YearMonth extends Temporal {
                 case ChronoField.YEAR: return this._year;
                 case ChronoField.ERA: return (this._year < 1 ? 0 : 1);
             }
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.getFrom(this);
     }
@@ -540,39 +539,12 @@ export class YearMonth extends Temporal {
      */
     with(adjusterOrField, value) {
         if (arguments.length === 1) {
-            return this.withAdjuster(adjusterOrField);
+            return this._withAdjuster(adjusterOrField);
         } else {
-            return this.withFieldValue(adjusterOrField, value);
+            return this._withField(adjusterOrField, value);
         }
     }
 
-    /**
-     * Returns an adjusted copy of this year-month.
-     *
-     * This returns a new {@link YearMonth}, based on this one, with the year-month adjusted.
-     * The adjustment takes place using the specified adjuster strategy object.
-     * Read the documentation of the adjuster to understand what adjustment will be made.
-     *
-     * A simple adjuster might simply set the one of the fields, such as the year field.
-     * A more complex adjuster might set the year-month to the next month that
-     * Halley's comet will pass the Earth.
-     *
-     * The result of this method is obtained by invoking the
-     * {@link TemporalAdjuster#adjustInto} method on the
-     * specified adjuster passing `this` as the argument.
-     *
-     * This instance is immutable and unaffected by this method call.
-     *
-     * @param {TemporalAdjuster} adjuster the adjuster to use, not null
-     * @return {YearMonth} based on `this` with the adjustment made, not null
-     * @throws DateTimeException if the adjustment cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    withAdjuster(adjuster) {
-        requireNonNull(adjuster, 'adjuster');
-        return adjuster.adjustInto(this);
-    }
-
     /**
      * Returns a copy of this year-month with the specified field set to a new value.
      *
@@ -619,7 +591,7 @@ export class YearMonth extends Temporal {
      * @throws DateTimeException if the field cannot be set
      * @throws ArithmeticException if numeric overflow occurs
      */
-    withFieldValue(field, newValue) {
+    _withField(field, newValue) {
         requireNonNull(field, 'field');
         requireInstance(field, TemporalField, 'field');
         if (field instanceof ChronoField) {
@@ -632,7 +604,7 @@ export class YearMonth extends Temporal {
                 case ChronoField.YEAR: return this.withYear(newValue);
                 case ChronoField.ERA: return (this.getLong(ChronoField.ERA) === newValue ? this : this.withYear(1 - this._year));
             }
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.adjustInto(this, newValue);
     }
@@ -668,28 +640,6 @@ export class YearMonth extends Temporal {
 
     //-----------------------------------------------------------------------
 
-    /**
-     * Returns a copy of this year-month with the specified period added.
-     *
-     * This method returns a new year-month based on this year-month with the specified period added.
-     * The adder is typically {@link Period} but may be any other type implementing
-     * the {@link TemporalAmount} interface.
-     * The calculation is delegated to the specified adjuster, which typically calls
-     * back to {@link plus}.
-     *
-     * This instance is immutable and unaffected by this method call.
-     *
-     * @param {TemporalAmount} amount  the amount to add, not null
-     * @return {YearMonth} based on this year-month with the addition made, not null
-     * @throws DateTimeException if the addition cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    plusAmount(amount) {
-        requireNonNull(amount, 'amount');
-        requireInstance(amount, TemporalAmount, 'amount');
-        return amount.addTo(this);
-    }
-
     /**
      * @param {number} amountToAdd
      * @param {TemporalUnit} unit
@@ -697,7 +647,7 @@ export class YearMonth extends Temporal {
      * @throws DateTimeException if the addition cannot be made
      * @throws ArithmeticException if numeric overflow occurs
      */
-    plusAmountUnit(amountToAdd, unit) {
+    _plusUnit(amountToAdd, unit) {
         requireNonNull(unit, 'unit');
         requireInstance(unit, TemporalUnit, 'unit');
         if (unit instanceof ChronoUnit) {
@@ -709,7 +659,7 @@ export class YearMonth extends Temporal {
                 case ChronoUnit.MILLENNIA: return this.plusYears(MathUtil.safeMultiply(amountToAdd, 1000));
                 case ChronoUnit.ERAS: return this.with(ChronoField.ERA, MathUtil.safeAdd(this.getLong(ChronoField.ERA), amountToAdd));
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.addTo(this, amountToAdd);
     }
@@ -753,38 +703,6 @@ export class YearMonth extends Temporal {
 
     //-----------------------------------------------------------------------
 
-    /**
-     * Returns a copy of this year-month with the specified period subtracted.
-     *
-     * This method returns a new year-month based on this year-month with the specified period subtracted.
-     * The subtractor is typically {@link Period} but may be any other type implementing
-     * the {@link TemporalAmount} interface.
-     * The calculation is delegated to the specified adjuster, which typically calls
-     * back to {@link minus}.
-     *
-     * This instance is immutable and unaffected by this method call.
-     *
-     * @param {TemporalAmount} amount  the amount to subtract, not null
-     * @return {YearMonth} based on this year-month with the subtraction made, not null
-     * @throws DateTimeException if the subtraction cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    minusAmount(amount) {
-        requireNonNull(amount, 'amount');
-        return amount.subtractFrom(this);
-    }
-
-    /**
-     * @param {number} amountToSubtract  the amount to subtract, not null
-     * @param {TemporalUnit} unit
-     * @return {YearMonth} based on this year-month with the subtraction made, not null
-     * @throws DateTimeException if the subtraction cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    minusAmountUnit(amountToSubtract, unit) {
-        return (amountToSubtract === MathUtil.MIN_SAFE_INTEGER ? this.plusAmountUnit(MathUtil.MAX_SAFE_INTEGER, unit).plusAmountUnit(1, unit) : this.plusAmountUnit(-amountToSubtract, unit));
-    }
-
     /**
      * Returns a copy of this year-month with the specified period in years subtracted.
      *
@@ -939,7 +857,7 @@ export class YearMonth extends Temporal {
                 case ChronoUnit.MILLENNIA: return monthsUntil / 12000;
                 case ChronoUnit.ERAS: return end.getLong(ChronoField.ERA) - this.getLong(ChronoField.ERA);
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.between(this, end);
     }

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}`);
     }
 
 
@@ -175,8 +175,8 @@ export class ZoneIdFactory {
         requireNonNull(temporal, 'temporal');
         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 : ''));
+            throw new DateTimeException(`Unable to obtain ZoneId from TemporalAccessor: ${ 
+                temporal}, type ${temporal.constructor != null ? temporal.constructor.name : ''}`);
         }
         return obj;
     }