@js-joda/core 1.12.0 → 3.2.0

package/src/Year.js

@@ -463,24 +463,6 @@ export class Year extends Temporal {
     }
 
     //-----------------------------------------------------------------------
-    /**
-     * function overloading for {@link YearMonth.with}
-     *
-     * if called with 2 arguments and first argument is an instance of TemporalField, then {@link Year.withFieldValue} is executed,
-
-     * otherwise {@link Year.withAdjuster} is executed,
-     *
-     * @param {!(TemporalAdjuster|TemporalField|Number)} adjusterOrFieldOrNumber
-     * @param {?number} value nullable only of first argument is an instance of TemporalAdjuster
-     * @returns {Year}
-     */
-    with(adjusterOrFieldOrNumber, value) {
-        if (arguments.length === 2 && adjusterOrFieldOrNumber instanceof TemporalField) {
-            return this.withFieldValue(adjusterOrFieldOrNumber, value);
-        } else {
-            return this.withAdjuster(adjusterOrFieldOrNumber);
-        }
-    }
 
     /**
      * Returns an adjusted copy of this year.
@@ -562,25 +544,6 @@ export class Year extends Temporal {
         return field.adjustInto(this, newValue);
     }
 
-    /**
-     * function overloading for {@link Year.plus}
-     *
-     * if called with 1 arguments, then {@link Year.plusAmount} is executed.
-     *
-     * Otherwise {@link Year.plusAmountToAddUnit} is executed.
-     *
-     * @param {!(TemporalAmount|number)} amountOrNumber
-     * @param {?TemporalUnit} unit nullable only if first argument is an instance of TemporalAmount
-     * @returns {Year}
-     */
-    plus(amountOrNumber, unit) {
-        if (arguments.length === 1) {
-            return this.plusAmount(amountOrNumber);
-        } else {
-            return this.plusAmountToAddUnit(amountOrNumber, unit);
-        }
-    }
-
     /**
      * Returns a copy of this year with the specified period added.
      *
@@ -610,7 +573,7 @@ export class Year extends Temporal {
      * @throws DateTimeException if the addition cannot be made
      * @throws ArithmeticException if numeric overflow occurs
      */
-    plusAmountToAddUnit(amountToAdd, unit) {
+    plusAmountUnit(amountToAdd, unit) {
         requireNonNull(amountToAdd, 'amountToAdd');
         requireNonNull(unit, 'unit');
         requireInstance(unit, TemporalUnit, 'unit');
@@ -644,24 +607,6 @@ export class Year extends Temporal {
     }
 
     //-----------------------------------------------------------------------
-    /**
-     * function overloading for {@link Year.minus}
-     *
-     * if called with 1 argument, then {@link Year.minusAmount} is executed.
-     *
-     * Otherwise {@link Year.minusAmountToSubtractUnit} is executed.
-     *
-     * @param {!(TemporalAmount|number)} amountOrNumber
-     * @param {?TemporalUnit} unit
-     * @returns {Year}
-     */
-    minus(amountOrNumber, unit) {
-        if (arguments.length === 1) {
-            return this.minusAmount(amountOrNumber);
-        } else {
-            return this.minusAmountToSubtractUnit(amountOrNumber, unit);
-        }
-    }
 
     /**
      * Returns a copy of this year with the specified period subtracted.
@@ -692,7 +637,7 @@ export class Year extends Temporal {
      * @throws DateTimeException if the subtraction cannot be made
      * @throws ArithmeticException if numeric overflow occurs
      */
-    minusAmountToSubtractUnit(amountToSubtract, unit) {
+    minusAmountUnit(amountToSubtract, unit) {
         requireNonNull(amountToSubtract, 'amountToSubtract');
         requireNonNull(unit, 'unit');
         requireInstance(unit, TemporalUnit, 'unit');
@@ -980,6 +925,77 @@ export class Year extends Temporal {
     toJSON() {
         return this.toString();
     }
+
+    /**
+     * Calculates the amount of time until another temporal in terms of the specified unit.
+     * This calculates the amount of time between two temporal objects in terms of a single {@link TemporalUnit}. The start and end points are this and the specified temporal. The end point is converted to be of the same type as the start point if different. The result will be negative if the end is before the start. For example, the amount in hours between two temporal objects can be calculated using `startTime.until(endTime, HOURS)`.
+     *
+     * The calculation returns a whole number, representing the number of complete units between the two temporals. For example, the amount in hours between the times 11:30 and 13:29 will only be one hour as it is one minute short of two hours.
+     *
+     * There are two equivalent ways of using this method. The first is to invoke this method directly. The second is to use `TemporalUnit.between(Temporal, Temporal)`:
+     *
+     * <pre>
+     *    // these two lines are equivalent
+     *    temporal = start.until(end, unit);
+     *    temporal = unit.between(start, end);
+     * </pre>
+     *
+     * The choice should be made based on which makes the code more readable.
+     * For example, this method allows the number of days between two dates to be calculated:
+     *
+     * <pre>
+     *   daysBetween = start.until(end, DAYS);
+     *   // or alternatively
+     *   daysBetween = DAYS.between(start, end);
+     * </pre>
+     *
+     * ### Implementation Requirements:
+     * Implementations must begin by checking to ensure that the input temporal object is of the same observable type as the implementation. They must then perform the calculation for all instances of {@link ChronoUnit}. An {@link UnsupportedTemporalTypeException} must be thrown for {@link ChronoUnit} instances that are unsupported.
+     * If the unit is not a {@link ChronoUnit}, then the result of this method is obtained by invoking `TemporalUnit.between(Temporal, Temporal)` passing this as the first argument and the converted input temporal as the second argument.
+     *
+     * In summary, implementations must behave in a manner equivalent to this pseudo-code:
+     *
+     * <pre>
+     *   // convert the end temporal to the same type as this class
+     *   if (unit instanceof ChronoUnit) {
+     *     // if unit is supported, then calculate and return result
+     *     // else throw UnsupportedTemporalTypeException for unsupported units
+     *   }
+     *   return unit.between(this, convertedEndTemporal);
+     * </pre>
+     *
+     * Note that the unit's between method must only be invoked if the two temporal objects have exactly the same type evaluated by `getClass()`.
+     *
+     * Implementations must ensure that no observable state is altered when this read-only method is invoked.
+     *
+     * @param {Temporal} endExclusive - the end temporal, exclusive, converted to be of the same type as this object, not null
+     * @param {TemporalUnit} unit - the unit to measure the amount in, not null
+     * @return {number} the amount of time between this temporal object and the specified one in terms of the unit; positive if the specified object is later than this one, negative if it is earlier than this one
+     * @throws DateTimeException - if the amount cannot be calculated, or the end temporal cannot be converted to the same type as this temporal
+     * @throws UnsupportedTemporalTypeException - if the unit is not supported
+     * @throws ArithmeticException - if numeric overflow occurs
+     */
+    until(endExclusive, unit) {
+        const end = Year.from(endExclusive);
+
+        if (unit instanceof ChronoUnit) {
+            const yearsUntil = end.value() - this.value();
+            switch (unit) {
+                case ChronoUnit.YEARS:
+                    return yearsUntil;
+                case ChronoUnit.DECADES:
+                    return MathUtil.intDiv(yearsUntil, 10);
+                case ChronoUnit.CENTURIES:
+                    return MathUtil.intDiv(yearsUntil, 100);
+                case ChronoUnit.MILLENNIA:
+                    return MathUtil.intDiv(yearsUntil, 1000);
+                case ChronoUnit.ERAS:
+                    return end.getLong(ChronoField.ERA) - this.getLong(ChronoField.ERA);
+            }
+            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+        }
+        return unit.between(this, end);
+    }
 }
 
 let PARSER;

package/src/YearMonth.js

@@ -408,7 +408,7 @@ export class YearMonth extends Temporal {
      * @throws DateTimeException if a value for the field cannot be obtained
      * @throws ArithmeticException if numeric overflow occurs
      */
-    getLong( field) {
+    getLong(field) {
         requireNonNull(field, 'field');
         requireInstance(field, TemporalField, 'field');
         if (field instanceof ChronoField) {
@@ -532,40 +532,18 @@ export class YearMonth extends Temporal {
      * function overloading for {@link YearMonth.with}
      *
      * if called with 1 argument, then {@link YearMonth.withAdjuster} is executed,
+     * otherwise {@link YearMonth.withFieldValue} is executed.
      *
-     * if called with 2 arguments and first argument is an instance of TemporalField, then {@link YearMonth.withFieldValue} is executed,
-     *
-     * otherwise {@link YearMonth.withYearMonth} is executed
-     *
-     * @param {!(TemporalAdjuster|TemporalField|Number)} adjusterOrFieldOrNumber
+     * @param {!(TemporalAdjuster|TemporalField)} adjusterOrField
      * @param {?number} value nullable only of first argument is an instance of TemporalAdjuster
      * @returns {YearMonth}
      */
-    with(adjusterOrFieldOrNumber, value) {
+    with(adjusterOrField, value) {
         if (arguments.length === 1) {
-            return this.withAdjuster(adjusterOrFieldOrNumber);
-        } else if (arguments.length === 2 && adjusterOrFieldOrNumber instanceof TemporalField){
-            return this.withFieldValue(adjusterOrFieldOrNumber, value);
+            return this.withAdjuster(adjusterOrField);
         } else {
-            return this.withYearMonth(adjusterOrFieldOrNumber, value);
-        }
-    }
-
-    /**
-     * Returns a copy of this year-month with the new year and month, checking
-     * to see if a new object is in fact required.
-     *
-     * @param {number} newYear  the year to represent, validated from MIN_YEAR to MAX_YEAR
-     * @param {number} newMonth  the month-of-year to represent, validated not null
-     * @return the year-month, not null
-     */
-    withYearMonth(newYear, newMonth) {
-        requireNonNull(newYear);
-        requireNonNull(newMonth);
-        if (this._year === newYear && this._month === newMonth) {
-            return this;
+            return this.withFieldValue(adjusterOrField, value);
         }
-        return new YearMonth(newYear, newMonth);
     }
 
     /**
@@ -671,7 +649,7 @@ export class YearMonth extends Temporal {
      */
     withYear(year) {
         ChronoField.YEAR.checkValidValue(year);
-        return this.withYearMonth(year, this._month);
+        return new YearMonth(year, this._month);
     }
 
     /**
@@ -685,28 +663,10 @@ export class YearMonth extends Temporal {
      */
     withMonth(month) {
         ChronoField.MONTH_OF_YEAR.checkValidValue(month);
-        return this.withYearMonth(this._year, month);
+        return new YearMonth(this._year, month);
     }
 
     //-----------------------------------------------------------------------
-    /**
-     * function overloading for {@link YearMonth.plus}
-     *
-     * if called with 1 arguments, then {@link YearMonth.plusAmount} is executed.
-     *
-     * Otherwise {@link YearMonth.plusAmountUnit} is executed.
-     *
-     * @param {!(TemporalAmount|number)} amountOrNumber
-     * @param {?TemporalUnit} unit nullable only if first argument is an instance of TemporalAmount
-     * @returns {YearMonth}
-     */
-    plus(amountOrNumber, unit) {
-        if (arguments.length === 1) {
-            return this.plusAmount(amountOrNumber);
-        } else {
-            return this.plusAmountUnit(amountOrNumber, unit);
-        }
-    }
 
     /**
      * Returns a copy of this year-month with the specified period added.
@@ -768,7 +728,7 @@ export class YearMonth extends Temporal {
             return this;
         }
         const newYear = ChronoField.YEAR.checkValidIntValue(this._year + yearsToAdd);  // safe overflow
-        return this.withYearMonth(newYear, this._month);
+        return this.withYear(newYear);
     }
 
     /**
@@ -788,28 +748,10 @@ export class YearMonth extends Temporal {
         const calcMonths = monthCount + monthsToAdd;
         const newYear = ChronoField.YEAR.checkValidIntValue(MathUtil.floorDiv(calcMonths, 12));
         const newMonth = MathUtil.floorMod(calcMonths, 12) + 1;
-        return this.withYearMonth(newYear, newMonth);
+        return new YearMonth(newYear, newMonth);
     }
 
     //-----------------------------------------------------------------------
-    /**
-     * function overloading for {@link YearMonth.minus}
-     *
-     * if called with 1 arguments, then {@link YearMonth.minusAmount} is executed.
-     *
-     * Otherwise {@link YearMonth.minusAmountUnit} is executed.
-     *
-     * @param {!(TemporalAmount|number)} amountOrNumber
-     * @param {?TemporalUnit} unit
-     * @returns {YearMonth}
-     */
-    minus(amountOrNumber, unit) {
-        if (arguments.length === 1) {
-            return this.minusAmount(amountOrNumber);
-        } else {
-            return this.minusAmountUnit(amountOrNumber, unit);
-        }
-    }
 
     /**
      * Returns a copy of this year-month with the specified period subtracted.

package/src/ZonedDateTime.js

@@ -13,6 +13,7 @@ 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';
 
@@ -975,19 +976,6 @@ export class ZonedDateTime extends ChronoZonedDateTime {
     }
 
     //-----------------------------------------------------------------------
-    /**
-     * function overloading for {@link ZonedDateTime.with}
-     *
-     * if called with 1 argument {@link ZonedDateTime.withTemporalAdjuster} is applied
-     * otherwise {@link ZonedDateTime.with2}
-     */
-    with(){
-        if(arguments.length === 1){
-            return this.withTemporalAdjuster.apply(this, arguments);
-        } else {
-            return this.with2.apply(this, arguments);
-        }
-    }
 
     /**
      * Returns an adjusted copy of this date-time.
@@ -1041,7 +1029,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @throws DateTimeException if the adjustment cannot be made
      * @throws ArithmeticException if numeric overflow occurs
      */
-    withTemporalAdjuster(adjuster) {
+    withAdjuster(adjuster) {
         // optimizations
         if (adjuster instanceof LocalDate) {
             return this._resolveLocal(LocalDateTime.of(adjuster, this._dateTime.toLocalTime()));
@@ -1110,7 +1098,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @throws UnsupportedTemporalTypeException if the field is not supported
      * @throws ArithmeticException if numeric overflow occurs
      */
-    with2(field, newValue) {
+    withFieldValue(field, newValue) {
         if (field instanceof ChronoField) {
             switch (field) {
                 case ChronoField.INSTANT_SECONDS: return ZonedDateTime._create(newValue, this.nano(), this._zone);
@@ -1336,19 +1324,6 @@ export class ZonedDateTime extends ChronoZonedDateTime {
     }
 
     //-----------------------------------------------------------------------
-    /**
-     * function overloading for {@link ZonedDateTime.plus}
-     *
-     * if called with 1 argument {@link ZonedDateTime.plusTemporalAmount} is applied,
-     * otherwise {@link ZonedDateTime.plus2}
-     */
-    plus(){
-        if(arguments.length === 1){
-            return this.plusTemporalAmount.apply(this, arguments);
-        } else {
-            return this.plus2.apply(this, arguments);
-        }
-    }
 
     /**
      * Returns a copy of this date-time with the specified period added.
@@ -1366,7 +1341,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @throws DateTimeException if the addition cannot be made
      * @throws ArithmeticException if numeric overflow occurs
      */
-    plusTemporalAmount(amount) {
+    plusAmount(amount) {
         requireNonNull(amount);
         return amount.addTo(this);
     }
@@ -1400,7 +1375,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @return {ZonedDateTime} a {@link ZonedDateTime} based on this date-time with the specified period added, not null
      * @throws DateTimeException if the unit cannot be added to this type
      */
-    plus2(amountToAdd, unit) {
+    plusAmountUnit(amountToAdd, unit) {
         if (unit instanceof ChronoUnit) {
             if (unit.isDateBased()) {
                 return this._resolveLocal(this._dateTime.plus(amountToAdd, unit));
@@ -1580,19 +1555,6 @@ export class ZonedDateTime extends ChronoZonedDateTime {
     }
 
     //-----------------------------------------------------------------------
-    /**
-     * function overloading for {@link ZonedDateTime.minus}
-     *
-     * if called with 1 argument {@link ZonedDateTime.minusTemporalAmount} is applied,
-     * otherwise {@link ZonedDateTime.minus2}
-     */
-    minus(){
-        if(arguments.length === 1){
-            return this.minusTemporalAmount.apply(this, arguments);
-        } else {
-            return this.minus2.apply(this, arguments);
-        }
-    }
 
     /**
      * Returns a copy of this date-time with the specified period subtracted.
@@ -1610,7 +1572,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @throws DateTimeException if the subtraction cannot be made
      * @throws ArithmeticException if numeric overflow occurs
      */
-    minusTemporalAmount(amount) {
+    minusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.subtractFrom(this);
     }
@@ -1644,8 +1606,8 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @return {ZonedDateTime} a {@link ZonedDateTime} based on this date-time with the specified period subtracted, not null
      * @throws DateTimeException if the unit cannot be added to this type
      */
-    minus2(amountToSubtract, unit) {
-        return this.plus2(-1 * amountToSubtract, unit);
+    minusAmountUnit(amountToSubtract, unit) {
+        return this.plusAmountUnit(-1 * amountToSubtract, unit);
     }
 
     //-----------------------------------------------------------------------
@@ -1963,12 +1925,9 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      *
      * @return {OffsetDateTime} an offset date-time representing the same local date-time and offset, not null
      */
-    /**
-     * we will not support OffsetDateTime in the near future
-        toOffsetDateTime() {
-            return OffsetDateTime.of(this._dateTime, this._offset);
-        }
-    */
+    toOffsetDateTime() {
+        return OffsetDateTime.of(this._dateTime, this._offset);
+    }
 
     //-----------------------------------------------------------------------
     /**

package/src/_init.js

@@ -12,6 +12,8 @@ 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';
@@ -59,6 +61,8 @@ function init() {
     IsoChronologyInit();
     DateTimeFormatterInit();
     DateTimeFormatterBuilderInit();
+    OffsetDateTimeInit();
+    OffsetTimeInit();
 }
 
 init();

package/src/chrono/ChronoLocalDate.js

@@ -10,7 +10,7 @@ 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 {DefaultInterfaceTemporal} from '../temporal/DefaultInterfaceTemporal';
 
 import {LocalDate} from '../LocalDate';
 
@@ -180,7 +180,7 @@ import {LocalDate} from '../LocalDate';
  * In JDK 8, this is an interface with default methods.
  * Since there are no default methods in JDK 7, an abstract class is used.
  */
-export class ChronoLocalDate extends Temporal {
+export class ChronoLocalDate extends DefaultInterfaceTemporal {
 
     isSupported(fieldOrUnit) {
         if (fieldOrUnit instanceof ChronoField) {

package/src/chrono/ChronoLocalDateTime.js

@@ -12,7 +12,7 @@ import {Instant} from '../Instant';
 import {ZoneOffset} from '../ZoneOffset';
 import {ChronoUnit} from '../temporal/ChronoUnit';
 import {ChronoField} from '../temporal/ChronoField';
-import {Temporal} from '../temporal/Temporal';
+import {DefaultInterfaceTemporal} from '../temporal/DefaultInterfaceTemporal';
 import {TemporalQueries} from '../temporal/TemporalQueries';
 
 /**
@@ -49,7 +49,7 @@ import {TemporalQueries} from '../temporal/TemporalQueries';
  *
  * @param D the date type
  */
-export class ChronoLocalDateTime extends Temporal {
+export class ChronoLocalDateTime extends DefaultInterfaceTemporal {
     /* <D extends ChronoLocalDate>
         extends DefaultInterfaceTemporal
         implements Temporal, TemporalAdjuster, Comparable<ChronoLocalDateTime<?>> */

package/src/chrono/ChronoZonedDateTime.js

@@ -10,10 +10,10 @@ import {LocalDate} from '../LocalDate';
 import {MathUtil} from '../MathUtil';
 
 import {ChronoUnit} from '../temporal/ChronoUnit';
-import {Temporal} from '../temporal/Temporal';
+import {DefaultInterfaceTemporal} from '../temporal/DefaultInterfaceTemporal';
 import {TemporalQueries} from '../temporal/TemporalQueries';
 
-export class ChronoZonedDateTime  extends Temporal {
+export class ChronoZonedDateTime  extends DefaultInterfaceTemporal {
     query(query) {
         if (query === TemporalQueries.zoneId() || query === TemporalQueries.zone()) {
             return this.zone();

package/src/errors.js

@@ -4,8 +4,8 @@
  */
 
 function createErrorType(name, init, superErrorClass = Error) {
-    function E(message) {
-        if (!Error.captureStackTrace){
+    function JsJodaException(message) {
+        if (!Error.captureStackTrace) {
             this.stack = (new Error()).stack;
         } else {
             Error.captureStackTrace(this, this.constructor);
@@ -16,10 +16,10 @@ function createErrorType(name, init, superErrorClass = Error) {
             return `${this.name}: ${this.message}`;
         };
     }
-    E.prototype = new superErrorClass();
-    E.prototype.name = name;
-    E.prototype.constructor = E;
-    return E;
+    JsJodaException.prototype = Object.create(superErrorClass.prototype);
+    JsJodaException.prototype.name = name;
+    JsJodaException.prototype.constructor = JsJodaException;
+    return JsJodaException;
 }
 
 export const DateTimeException = createErrorType('DateTimeException', messageWithCause);

package/src/format/DateTimeBuilder.js

@@ -14,7 +14,7 @@ import {ResolverStyle} from './ResolverStyle';
 import {IsoChronology} from '../chrono/IsoChronology';
 import {ChronoLocalDate} from '../chrono/ChronoLocalDate';
 import {ChronoField} from '../temporal/ChronoField';
-import {Temporal} from '../temporal/Temporal';
+import {TemporalAccessor} from '../temporal/TemporalAccessor';
 import {TemporalQueries} from '../temporal/TemporalQueries';
 
 import {LocalTime} from '../LocalTime';
@@ -36,7 +36,7 @@ import {ZoneOffset} from '../ZoneOffset';
  *
  *   @private
  */
-export class DateTimeBuilder extends Temporal {
+export class DateTimeBuilder extends TemporalAccessor {
 
     /**
      * Creates a new instance of the builder with a single field-value.

package/src/format/DateTimeFormatter.js

@@ -704,9 +704,9 @@ export function _init() {
         .toFormatter(ResolverStyle.STRICT);
 
     // TODO:
-    //  ISO_DATE - https://docs.oracle.com/javase/10/docs/api/java/time/format/DateTimeFormatter.html#ISO_DATE
-    //  ISO_TIME - https://docs.oracle.com/javase/10/docs/api/java/time/format/DateTimeFormatter.html#ISO_TIME
-    //  ISO_DATE_TIME - https://docs.oracle.com/javase/10/docs/api/java/time/format/DateTimeFormatter.html#ISO_DATE_TIME
+    //  ISO_DATE - https://www.threeten.org/threetenbp/apidocs/org/threeten/bp/format/DateTimeFormatter.html#ISO_DATE
+    //  ISO_TIME - https://www.threeten.org/threetenbp/apidocs/org/threeten/bp/format/DateTimeFormatter.html#ISO_TIME
+    //  ISO_DATE_TIME - https://www.threeten.org/threetenbp/apidocs/org/threeten/bp/format/DateTimeFormatter.html#ISO_DATE_TIME
 
     DateTimeFormatter.PARSED_EXCESS_DAYS = createTemporalQuery('PARSED_EXCESS_DAYS', (temporal) => {
         if (temporal instanceof DateTimeBuilder) {

package/src/js-joda.js

@@ -22,6 +22,8 @@ import { LocalTime } from './LocalTime';
 import { LocalDateTime } from './LocalDateTime';
 import { Month } from './Month';
 import { MonthDay } from './MonthDay';
+import { OffsetDateTime } from './OffsetDateTime';
+import { OffsetTime } from './OffsetTime';
 import { Period } from './Period';
 import { Year } from './Year';
 import { YearConstants } from './YearConstants';
@@ -105,6 +107,8 @@ const jsJodaExports = {
     LocalDate,
     LocalTime,
     LocalDateTime,
+    OffsetTime,
+    OffsetDateTime,
     Month,
     MonthDay,
     Period,
@@ -167,6 +171,8 @@ export {
     LocalDateTime,
     Month,
     MonthDay,
+    OffsetTime,
+    OffsetDateTime,
     Period,
     Year,
     YearConstants,