@js-joda/core 3.2.0 → 4.2.1

package/src/LocalTime.js

@@ -5,22 +5,23 @@
  */
 
 
-import {MathUtil} from './MathUtil';
-import {assert, requireNonNull, requireInstance} from './assert';
-import {DateTimeException, UnsupportedTemporalTypeException, IllegalArgumentException} from './errors';
+import { MathUtil } from './MathUtil';
+import { requireNonNull, requireInstance } from './assert';
+import { DateTimeException, UnsupportedTemporalTypeException } from './errors';
 
-import {Clock} from './Clock';
-import {LocalDateTime} from './LocalDateTime';
-import {ZoneId} from './ZoneId';
+import { Clock } from './Clock';
+import { LocalDateTime } from './LocalDateTime';
+import { ZoneId } from './ZoneId';
+import { OffsetTime } from './OffsetTime';
 
-import {DateTimeFormatter} from './format/DateTimeFormatter';
+import { DateTimeFormatter } from './format/DateTimeFormatter';
 
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {Temporal} from './temporal/Temporal';
-import {TemporalField} from './temporal/TemporalField';
-import {TemporalQueries} from './temporal/TemporalQueries';
-import {createTemporalQuery} from './temporal/TemporalQuery';
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { Temporal } from './temporal/Temporal';
+import { TemporalField } from './temporal/TemporalField';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { createTemporalQuery } from './temporal/TemporalQuery';
 
 /**
  * A time without time-zone in the ISO-8601 calendar system,
@@ -460,7 +461,7 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
             case ChronoField.CLOCK_HOUR_OF_DAY: return (this._hour === 0 ? 24 : this._hour);
             case ChronoField.AMPM_OF_DAY: return MathUtil.intDiv(this._hour, 12);
         }
-        throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+        throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
     }
 
     //-----------------------------------------------------------------------
@@ -521,14 +522,13 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
      * @throws {DateTimeException} if the adjustment cannot be made
      * @throws {ArithmeticException} if numeric overflow occurs
      */
-    withAdjuster(adjuster) {
+    _withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
         // optimizations
         if (adjuster instanceof LocalTime) {
             return adjuster;
         }
-        assert(typeof adjuster.adjustInto === 'function', 'adjuster', IllegalArgumentException);
-        return adjuster.adjustInto(this);
+        return super._withAdjuster(adjuster);
     }
 
     /**
@@ -611,7 +611,7 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
      * @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) {
@@ -633,7 +633,7 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
                 case ChronoField.CLOCK_HOUR_OF_DAY: return this.withHour((newValue === 24 ? 0 : newValue));
                 case ChronoField.AMPM_OF_DAY: return this.plusHours((newValue - MathUtil.intDiv(this._hour, 12)) * 12);
             }
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.adjustInto(this, newValue);
     }
@@ -742,27 +742,6 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
 
     //-----------------------------------------------------------------------
 
-    /**
-     * Returns a copy of this date with the specified period added.
-     *
-     * This method returns a new time based on this time with the specified period added.
-     * The amount 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 {LocalTime} a {@link LocalTime} based on this time 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');
-        return amount.addTo(this);
-    }
-
     /**
      * Returns a copy of this time with the specified period added.
      *
@@ -778,7 +757,7 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
      * @return {LocalTime} a {@link LocalTime} based on this time with the specified period added, not null
      * @throws {DateTimeException} if the unit cannot be added to this type
      */
-    plusAmountUnit(amountToAdd, unit) {
+    _plusUnit(amountToAdd, unit) {
         requireNonNull(unit, 'unit');
         if (unit instanceof ChronoUnit) {
             switch (unit) {
@@ -790,7 +769,7 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
                 case ChronoUnit.HOURS: return this.plusHours(amountToAdd);
                 case ChronoUnit.HALF_DAYS: return this.plusHours(MathUtil.intMod(amountToAdd, 2) * 12);
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.addTo(this, amountToAdd);
     }
@@ -897,28 +876,6 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
 
     //-----------------------------------------------------------------------
 
-    /**
-     * Returns a copy of this time with the specified period subtracted.
-     *
-     * This method returns a new time based on this time with the specified period subtracted.
-     * The amount 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 {LocalTime} a {@link LocalTime} based on this time 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);
-    }
-
     /**
      * Returns a copy of this time with the specified period subtracted.
      *
@@ -934,9 +891,9 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
      * @return {LocalTime} a {@link LocalTime} based on this time with the specified period subtracted, not null
      * @throws {DateTimeException} if the unit cannot be added to this type
      */
-    minusAmountUnit(amountToSubtract, unit) {
+    _minusUnit(amountToSubtract, unit) {
         requireNonNull(unit, 'unit');
-        return this.plusAmountUnit(-1 * amountToSubtract, unit);
+        return this._plusUnit(-1 * amountToSubtract, unit);
     }
 
     //-----------------------------------------------------------------------
@@ -1120,7 +1077,7 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
                 case ChronoUnit.HOURS: return MathUtil.intDiv(nanosUntil, LocalTime.NANOS_PER_HOUR);
                 case ChronoUnit.HALF_DAYS: return MathUtil.intDiv(nanosUntil, (12 * LocalTime.NANOS_PER_HOUR));
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.between(this, end);
     }
@@ -1148,11 +1105,9 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
      * @param {OffsetTime} offset - the offset to combine with, not null
      * @return {OffsetTime} the offset time formed from this time and the specified offset, not null
      */
-    /*
     atOffset(offset) {
         return OffsetTime.of(this, offset);
     }
-*/
 
     //-----------------------------------------------------------------------
     /**
@@ -1300,11 +1255,11 @@ export class LocalTime extends Temporal /** implements Temporal, TemporalAdjuste
             if (nanoValue > 0) {
                 buf += '.';
                 if(MathUtil.intMod(nanoValue, 1000000) === 0) {
-                    buf += ('' + (MathUtil.intDiv(nanoValue, 1000000) + 1000)).substring(1);
+                    buf += (`${MathUtil.intDiv(nanoValue, 1000000) + 1000}`).substring(1);
                 } else if (MathUtil.intMod(nanoValue, 1000) === 0) {
-                    buf += ('' + (MathUtil.intDiv(nanoValue, 1000) + 1000000)).substring(1);
+                    buf += (`${MathUtil.intDiv(nanoValue, 1000) + 1000000}`).substring(1);
                 } else {
-                    buf += ('' + (nanoValue + 1000000000)).substring(1);
+                    buf += (`${nanoValue + 1000000000}`).substring(1);
                 }
             }
         }

package/src/MathUtil.js

@@ -3,7 +3,7 @@
  * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
-import {ArithmeticException} from './errors';
+import { ArithmeticException } from './errors';
 
 export const MAX_SAFE_INTEGER = 9007199254740991;
 export const MIN_SAFE_INTEGER = -9007199254740991;
@@ -132,7 +132,7 @@ export class MathUtil {
         }
         const r = MathUtil.safeToInt(x * y);
         if (r / y !== x || (x === MIN_SAFE_INTEGER && y === -1) || (y === MIN_SAFE_INTEGER && x === -1)) {
-            throw new ArithmeticException('Multiplication overflows: ' + x + ' * ' + y);
+            throw new ArithmeticException(`Multiplication overflows: ${x} * ${y}`);
         }
         return r;
     }
@@ -172,7 +172,7 @@ export class MathUtil {
             throw new ArithmeticException(`Invalid value: '${value}' is a float`);
         }
         if (value > MAX_SAFE_INTEGER || value < MIN_SAFE_INTEGER) {
-            throw new ArithmeticException('Calculation overflows an int: ' + value);
+            throw new ArithmeticException(`Calculation overflows an int: ${value}`);
         }
     }
 

package/src/Month.js

@@ -4,15 +4,15 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {assert, requireNonNull, requireInstance} from './assert';
-import {MathUtil} from './MathUtil';
+import { assert, requireNonNull, requireInstance } from './assert';
+import { MathUtil } from './MathUtil';
 
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {DateTimeException, IllegalArgumentException, UnsupportedTemporalTypeException} from './errors';
-import {IsoChronology} from './chrono/IsoChronology';
-import {TemporalAccessor} from './temporal/TemporalAccessor';
-import {TemporalQueries} from './temporal/TemporalQueries';
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { DateTimeException, IllegalArgumentException, UnsupportedTemporalTypeException } from './errors';
+import { IsoChronology } from './chrono/IsoChronology';
+import { TemporalAccessor } from './temporal/TemporalAccessor';
+import { TemporalQueries } from './temporal/TemporalQueries';
 
 /**
  * A month-of-year, such as 'July'.
@@ -179,7 +179,7 @@ export class Month extends TemporalAccessor {
         if (field === ChronoField.MONTH_OF_YEAR) {
             return this.value();
         } else if (field instanceof ChronoField) {
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.getFrom(this);
     }
@@ -425,7 +425,7 @@ export class Month extends TemporalAccessor {
             case Month.DECEMBER:
                 return 'DECEMBER';
             default:
-                return 'unknown Month, value: ' + this.value();
+                return `unknown Month, value: ${this.value()}`;
         }
     }
 
@@ -537,7 +537,7 @@ export class Month extends TemporalAccessor {
      **/
     static of(month) {
         if (month < 1 || month > 12) {
-            assert(false, 'Invalid value for MonthOfYear: ' + month, DateTimeException);
+            assert(false, `Invalid value for MonthOfYear: ${month}`, DateTimeException);
         }
         return MONTHS[month-1];
     }
@@ -571,8 +571,8 @@ export class Month extends TemporalAccessor {
             }*/
             return Month.of(temporal.get(ChronoField.MONTH_OF_YEAR));
         } catch (ex) {
-            throw new DateTimeException('Unable to obtain Month from TemporalAccessor: ' +
-                    temporal + ' of type ' + (temporal && temporal.constructor != null ? temporal.constructor.name : ''), ex);
+            throw new DateTimeException(`Unable to obtain Month from TemporalAccessor: ${ 
+                temporal} of type ${temporal && temporal.constructor != null ? temporal.constructor.name : ''}`, ex);
         }
     }
 }

package/src/MonthDay.js

@@ -3,23 +3,23 @@
  * @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 {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 {TemporalAccessor} from './temporal/TemporalAccessor';
-import {TemporalQuery, createTemporalQuery} from './temporal/TemporalQuery';
-import {TemporalQueries} from './temporal/TemporalQueries';
-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 { 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 { TemporalAccessor } from './temporal/TemporalAccessor';
+import { TemporalQuery, createTemporalQuery } from './temporal/TemporalQuery';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { ValueRange } from './temporal/ValueRange';
+import { Year } from './Year';
+import { ZoneId } from './ZoneId';
 
 /**
  * A month-day in the ISO-8601 calendar system, such as `--12-03`.
@@ -159,8 +159,8 @@ export class MonthDay extends TemporalAccessor {
         requireNonNull(month, 'month');
         ChronoField.DAY_OF_MONTH.checkValidValue(dayOfMonth);
         if (dayOfMonth > month.maxLength()) {
-            throw new DateTimeException('Illegal value for DayOfMonth field, value ' + dayOfMonth +
-                    ' is not valid for month ' + month.toString());
+            throw new DateTimeException(`Illegal value for DayOfMonth field, value ${dayOfMonth 
+            } is not valid for month ${month.toString()}`);
         }
         return new MonthDay(month.value(), dayOfMonth);
     }
@@ -217,8 +217,8 @@ export class MonthDay extends TemporalAccessor {
             }*/
             return MonthDay.of(temporal.get(ChronoField.MONTH_OF_YEAR), temporal.get(ChronoField.DAY_OF_MONTH));
         } catch (ex) {
-            throw new DateTimeException('Unable to obtain MonthDay from TemporalAccessor: ' +
-                    temporal + ', type ' + (temporal && temporal.constructor != null ? temporal.constructor.name : ''));
+            throw new DateTimeException(`Unable to obtain MonthDay from TemporalAccessor: ${ 
+                temporal}, type ${temporal && temporal.constructor != null ? temporal.constructor.name : ''}`);
         }
     }
     //-----------------------------------------------------------------------
@@ -448,7 +448,7 @@ export class MonthDay extends TemporalAccessor {
                 case ChronoField.DAY_OF_MONTH: return this._day;
                 case ChronoField.MONTH_OF_YEAR: return this._month;
             }
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.getFrom(this);
     }
@@ -681,9 +681,9 @@ export class MonthDay extends TemporalAccessor {
      * @return {String} a string representation of this month-day, not null
      */
     toString() {
-        return '--'
-            + (this._month < 10 ? '0' : '') + this._month
-            + (this._day < 10 ? '-0' : '-') + this._day;
+        return `--${
+            this._month < 10 ? '0' : ''}${this._month
+        }${this._day < 10 ? '-0' : '-'}${this._day}`;
     }
 
     /**

package/src/OffsetDateTime.js

@@ -4,32 +4,32 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {Clock} from './Clock';
-import {DateTimeFormatter} from './format/DateTimeFormatter';
-import {DefaultInterfaceTemporal} from './temporal/DefaultInterfaceTemporal';
-import {Instant} from './Instant';
-import {IsoChronology} from './chrono/IsoChronology';
-import {LocalDateTime} from './LocalDateTime';
-import {LocalDate} from './LocalDate';
-import {LocalTime} from './LocalTime';
-import {MathUtil} from './MathUtil';
-import {OffsetTime} from './OffsetTime';
-import {TemporalQueries} from './temporal/TemporalQueries';
-import {ZonedDateTime} from './ZonedDateTime';
-import {ZoneId} from './ZoneId';
-import {ZoneOffset} from './ZoneOffset';
-import {DateTimeException, IllegalArgumentException} from './errors';
-
-import {createTemporalQuery} from './temporal/TemporalQuery';
-import {requireInstance, requireNonNull} from './assert';
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { Temporal } from './temporal/Temporal';
+import { Clock } from './Clock';
+import { DateTimeFormatter } from './format/DateTimeFormatter';
+import { Instant } from './Instant';
+import { IsoChronology } from './chrono/IsoChronology';
+import { LocalDateTime } from './LocalDateTime';
+import { LocalDate } from './LocalDate';
+import { LocalTime } from './LocalTime';
+import { MathUtil } from './MathUtil';
+import { OffsetTime } from './OffsetTime';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { ZonedDateTime } from './ZonedDateTime';
+import { ZoneId } from './ZoneId';
+import { ZoneOffset } from './ZoneOffset';
+import { DateTimeException, IllegalArgumentException } from './errors';
+
+import { createTemporalQuery } from './temporal/TemporalQuery';
+import { requireInstance, requireNonNull } from './assert';
 
 /**
  * A date-time with an offset from UTC/Greenwich in the ISO-8601 calendar system,
  * such as 2007-12-23T10:15:30+01:00.
  */
-export class OffsetDateTime extends DefaultInterfaceTemporal {
+export class OffsetDateTime extends Temporal {
     /**
      * @param {TemporaroAccessor} temporal
      * @return {OffsetDateTime}
@@ -169,7 +169,7 @@ export class OffsetDateTime extends DefaultInterfaceTemporal {
     }
 
     /**
-     * @param {ZoneId}zone
+     * @param {ZoneId} zone
      * @return {ZonedDateTime}
      */
     atZoneSameInstant(zone) {
@@ -205,7 +205,7 @@ export class OffsetDateTime extends DefaultInterfaceTemporal {
     get(field) {
         if (field instanceof ChronoField) {
             switch (field) {
-                case ChronoField.INSTANT_SECONDS: throw new DateTimeException('Field too large for an int: ' + field);
+                case ChronoField.INSTANT_SECONDS: throw new DateTimeException(`Field too large for an int: ${field}`);
                 case ChronoField.OFFSET_SECONDS: return this.offset().totalSeconds();
             }
             return this._dateTime.get(field);
@@ -373,7 +373,7 @@ export class OffsetDateTime extends DefaultInterfaceTemporal {
         return field.rangeRefinedBy(this);
     }
 
-    withAdjuster(adjuster) {
+    _withAdjuster(adjuster) {
         requireNonNull(adjuster);
         // optimizations
         if (adjuster instanceof LocalDate || adjuster instanceof LocalTime || adjuster instanceof LocalDateTime) {
@@ -388,7 +388,7 @@ export class OffsetDateTime extends DefaultInterfaceTemporal {
         return adjuster.adjustInto(this);
     }
 
-    withFieldValue(field, newValue) {
+    _withField(field, newValue) {
         requireNonNull(field);
         if (field instanceof ChronoField) {
             const f = field;
@@ -505,12 +505,12 @@ export class OffsetDateTime extends DefaultInterfaceTemporal {
         return this._withDateTimeOffset(this._dateTime.truncatedTo(unit), this._offset);
     }
 
-    plusAmount(amount) {
+    _plusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.addTo(this);
     }
 
-    plusAmountUnit(amountToAdd, unit) {
+    _plusUnit(amountToAdd, unit) {
         if (unit instanceof ChronoUnit) {
             return this._withDateTimeOffset(this._dateTime.plus(amountToAdd, unit), this._offset);
         }
@@ -581,12 +581,12 @@ export class OffsetDateTime extends DefaultInterfaceTemporal {
         return this._withDateTimeOffset(this._dateTime.plusNanos(nanos), this._offset);
     }
 
-    minusAmount(amount) {
+    _minusAmount(amount) {
         requireNonNull(amount);
         return amount.subtractFrom(this);
     }
 
-    minusAmountUnit(amountToSubtract, unit) {
+    _minusUnit(amountToSubtract, unit) {
         return this.plus(-1 * amountToSubtract, unit);
     }
 

package/src/OffsetTime.js

@@ -4,26 +4,26 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {Clock} from './Clock';
-import {DateTimeException, UnsupportedTemporalTypeException} from './errors';
-import {DateTimeFormatter} from './format/DateTimeFormatter';
-import {DefaultInterfaceTemporal} from './temporal/DefaultInterfaceTemporal';
-import {Instant, LocalTime} from './js-joda';
-import {MathUtil} from './MathUtil';
-import {OffsetDateTime} from './OffsetDateTime';
-import {TemporalQueries} from './temporal/TemporalQueries';
-import {ZoneId} from './ZoneId';
-import {ZoneOffset} from './ZoneOffset';
-
-import {createTemporalQuery} from './temporal/TemporalQuery';
-import {requireInstance, requireNonNull} from './assert';
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { Temporal } from './temporal/Temporal';
+import { Clock } from './Clock';
+import { DateTimeException, UnsupportedTemporalTypeException } from './errors';
+import { DateTimeFormatter } from './format/DateTimeFormatter';
+import { Instant, LocalTime } from './js-joda';
+import { MathUtil } from './MathUtil';
+import { OffsetDateTime } from './OffsetDateTime';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { ZoneId } from './ZoneId';
+import { ZoneOffset } from './ZoneOffset';
+
+import { createTemporalQuery } from './temporal/TemporalQuery';
+import { requireInstance, requireNonNull } from './assert';
 
 /**
  * A time with an offset from UTC/Greenwich in the ISO-8601 calendar system, such as 10:15:30+01:00.
  */
-export class OffsetTime extends DefaultInterfaceTemporal {
+export class OffsetTime extends Temporal {
     /**
      * @param {!TemporalAccessor} temporal
      * @return {OffsetTime}
@@ -80,11 +80,11 @@ export class OffsetTime extends DefaultInterfaceTemporal {
     }
 
     /**
-     * @param {int}hour
-     * @param {int}minute
-     * @param {int}second
-     * @param {int}nanoOfSecond
-     * @param {ZoneOffset}offset
+     * @param {int} hour
+     * @param {int} minute
+     * @param {int} second
+     * @param {int} nanoOfSecond
+     * @param {ZoneOffset} offset
      * @return {OffsetTime}
      */
     static ofNumbers(hour, minute, second, nanoOfSecond, offset) {
@@ -93,8 +93,8 @@ export class OffsetTime extends DefaultInterfaceTemporal {
     }
 
     /**
-     * @param {LocalTime}time
-     * @param {ZoneOffset}offset
+     * @param {LocalTime} time
+     * @param {ZoneOffset} offset
      * @return {OffsetTime}
      */
     static ofTimeAndOffset(time, offset) {
@@ -318,16 +318,16 @@ export class OffsetTime extends DefaultInterfaceTemporal {
         return this._withLocalTimeOffset(this._time.minusNanos(nanos), this._offset);
     }
 
-    minusAmount(amount) {
+    _minusAmount(amount) {
         requireNonNull(amount);
         return amount.subtractFrom(this);
     }
 
-    minusAmountUnit(amountToSubtract, unit) {
+    _minusUnit(amountToSubtract, unit) {
         return this.plus(-1 * amountToSubtract, unit);
     }
 
-    plusAmount(amount) {
+    _plusAmount(amount) {
         requireNonNull(amount);
         return amount.addTo(this);
     }
@@ -338,7 +338,7 @@ export class OffsetTime extends DefaultInterfaceTemporal {
      * @param unit
      * @return {Temporal}
      */
-    plusAmountUnit(amountToAdd, unit) {
+    _plusUnit(amountToAdd, unit) {
         if (unit instanceof ChronoUnit) {
             return this._withLocalTimeOffset(this._time.plus(amountToAdd, unit), this._offset);
         }
@@ -450,7 +450,7 @@ export class OffsetTime extends DefaultInterfaceTemporal {
                 case ChronoUnit.HOURS: return Math.floor(nanosUntil / LocalTime.NANOS_PER_HOUR);
                 case ChronoUnit.HALF_DAYS: return Math.floor(nanosUntil / (12 * LocalTime.NANOS_PER_HOUR));
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.between(this, end);
     }
@@ -515,7 +515,7 @@ export class OffsetTime extends DefaultInterfaceTemporal {
         return nod - offsetNanos;
     }
 
-    withAdjuster(adjuster) {
+    _withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
         // optimizations
         if (adjuster instanceof LocalTime) {
@@ -528,7 +528,7 @@ export class OffsetTime extends DefaultInterfaceTemporal {
         return adjuster.adjustInto(this);
     }
 
-    withFieldValue(field, newValue) {
+    _withField(field, newValue) {
         requireNonNull(field, 'field');
         if (field instanceof ChronoField) {
             if (field === ChronoField.OFFSET_SECONDS) {
@@ -541,8 +541,8 @@ export class OffsetTime extends DefaultInterfaceTemporal {
 
     /**
      * @private
-     * @param {LocalTime}time
-     * @param {ZoneOffset}offset
+     * @param {LocalTime} time
+     * @param {ZoneOffset} offset
      * @return {OffsetTime}
      */
     _withLocalTimeOffset(time, offset) {