@attocash/cli 0.1.0

package/node_modules/@js-joda/core/src/Period.js

@@ -0,0 +1,933 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @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 {IsoChronology} from './chrono/IsoChronology';
+
+import {ChronoUnit} from './temporal/ChronoUnit';
+import {TemporalAmount} from './temporal/TemporalAmount';
+
+import {LocalDate} from './LocalDate';
+
+/**
+ * The pattern for parsing.
+ */
+const PATTERN = /([-+]?)P(?:([-+]?[0-9]+)Y)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)W)?(?:([-+]?[0-9]+)D)?/;
+
+/**
+ * A date-based amount of time, such as '2 years, 3 months and 4 days'.
+ *
+ * This class models a quantity or amount of time in terms of years, months and days.
+ * See {@link Duration} for the time-based equivalent to this class.
+ *
+ * Durations and period differ in their treatment of daylight savings time
+ * when added to {@link ZonedDateTime}. A {@link Duration} will add an exact
+ * number of seconds, thus a duration of one day is always exactly 24 hours.
+ * By contrast, a {@link Period} will add a conceptual day, trying to maintain
+ * the local time.
+ *
+ * For example, consider adding a period of one day and a duration of one day to
+ * 18:00 on the evening before a daylight savings gap. The {@link Period} will add
+ * the conceptual day and result in a {@link ZonedDateTime} at 18:00 the following day.
+ * By contrast, the {@link Duration} will add exactly 24 hours, resulting in a
+ * {@link ZonedDateTime} at 19:00 the following day (assuming a one hour DST gap).
+ *
+ * The supported units of a period are {@link ChronoUnit#YEARS},
+ * {@link ChronoUnit#MONTHS} and {@link ChronoUnit#DAYS}.
+ * All three fields are always present, but may be set to zero.
+ *
+ * The period may be used with any calendar system.
+ * The meaning of a 'year' or 'month' is only applied when the object is added to a date.
+ *
+ * The period is modeled as a directed amount of time, meaning that individual parts of the
+ * period may be negative.
+ *
+ * The months and years fields may be normalized (see {@link normalized}).
+ * The normalization assumes a 12 month year, so is not appropriate for all calendar systems.
+ *
+ * ### Static properties of Class {@link Period}
+ *
+ * Period.ZERO
+ *
+ * A constant for a period of zero.
+ *
+ */
+export class Period extends TemporalAmount /* extends ChronoPeriod */ {
+
+    /**
+     * do not call the constructor directly
+     * use a factory method instead
+     *
+     * @param {number} years
+     * @param {number} months
+     * @param {number} days
+     * @private
+     */
+    constructor(years, months, days){
+        super();
+        
+        const _years = MathUtil.safeToInt(years);
+        const _months =  MathUtil.safeToInt(months);
+        const _days = MathUtil.safeToInt(days);
+
+        if( _years === 0 && _months === 0 && _days === 0 ){
+            if (!Period.ZERO) {
+                this._years = _years;
+                this._months =  _months;
+                this._days = _days;
+                Period.ZERO = this;
+            }
+            return Period.ZERO;
+        }
+        
+        /**
+         * The number of years.
+         */
+        this._years = _years;
+        /**
+         * The number of months.
+         */
+        this._months =  _months;
+        /**
+         * The number of days.
+         */
+        this._days = _days;
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Obtains a {@link Period} representing a number of years.
+     *
+     * The resulting period will have the specified years.
+     * The months and days units will be zero.
+     *
+     * @param {number} years - the number of years, positive or negative
+     * @return {Period} the period of years, not null
+     */
+    static ofYears(years) {
+        return Period.create(years, 0, 0);
+    }
+
+    /**
+     * Obtains a {@link Period} representing a number of months.
+     *
+     * The resulting period will have the specified months.
+     * The years and days units will be zero.
+     *
+     * @param {number} months - the number of months, positive or negative
+     * @return {Period} the period of months, not null
+     */
+    static ofMonths(months) {
+        return Period.create(0, months, 0);
+    }
+
+    /**
+     * Obtains a {@link Period} representing a number of weeks.
+     *
+     * The resulting period will have days equal to the weeks multiplied by seven.
+     * The years and months units will be zero.
+     *
+     * @param {number} weeks - the number of weeks, positive or negative
+     * @return {Period} the period of days, not null
+     */
+    static ofWeeks(weeks) {
+        return Period.create(0, 0, MathUtil.safeMultiply(weeks, 7));
+    }
+
+    /**
+     * Obtains a {@link Period} representing a number of days.
+     *
+     * The resulting period will have the specified days.
+     * The years and months units will be zero.
+     *
+     * @param {number} days - the number of days, positive or negative
+     * @return {Period} the period of days, not null
+     */
+    static ofDays(days) {
+        return Period.create(0, 0, days);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Obtains a {@link Period} representing a number of years, months and days.
+     *
+     * This creates an instance based on years, months and days.
+     *
+     * @param {!number} years - the amount of years, may be negative
+     * @param {!number} months - the amount of months, may be negative
+     * @param {!number} days - the amount of days, may be negative
+     * @return {Period} the period of years, months and days, not null
+     */
+    static of(years, months, days) {
+        return Period.create(years, months, days);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Obtains an instance of {@link Period} from a temporal amount.
+     *
+     * This obtains a period based on the specified amount.
+     * A {@link TemporalAmount} represents an - amount of time, which may be
+     * date-based or time-based, which this factory extracts to a {@link Period}.
+     *
+     * The conversion loops around the set of units from the amount and uses
+     * the {@link ChronoUnit#YEARS}, {@link ChronoUnit#MONTHS}
+     * and {@link ChronoUnit#DAYS} units to create a period.
+     * If any other units are found then an exception is thrown.
+     *
+     * If the amount is a {@link ChronoPeriod} then it must use the ISO chronology.
+     *
+     * @param {TemporalAmount} amount - the temporal amount to convert, not null
+     * @return {Period} the equivalent period, not null
+     * @throws DateTimeException if unable to convert to a {@link Period}
+     * @throws ArithmeticException if the amount of years, months or days exceeds an int
+     */
+    static from(amount) {
+        if (amount instanceof Period) {
+            return amount;
+        }
+        /*
+        if (amount instanceof ChronoPeriod) {
+            if (IsoChronology.INSTANCE !== amount.chronology()) {
+                throw new DateTimeException('Period requires ISO chronology: ' + amount);
+            }
+        }
+*/
+        requireNonNull(amount, 'amount');
+        let years = 0;
+        let months = 0;
+        let days = 0;
+        const units = amount.units();
+        for (let i=0; i<units.length; i++) {
+            const unit = units[i];
+            const unitAmount = amount.get(unit);
+            if (unit === ChronoUnit.YEARS) {
+                years = MathUtil.safeToInt(unitAmount);
+            } else if (unit === ChronoUnit.MONTHS) {
+                months = MathUtil.safeToInt(unitAmount);
+            } else if (unit === ChronoUnit.DAYS) {
+                days = MathUtil.safeToInt(unitAmount);
+            } else {
+                throw new DateTimeException('Unit must be Years, Months or Days, but was ' + unit);
+            }
+        }
+        return Period.create(years, months, days);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Obtains a {@link Period} consisting of the number of years, months,
+     * and days between two dates.
+     *
+     * The start date is included, but the end date is not.
+     * The period is calculated by removing complete months, then calculating
+     * the remaining number of days, adjusting to ensure that both have the same sign.
+     * The number of months is then split into years and months based on a 12 month year.
+     * A month is considered if the end day-of-month is greater than or equal to the start day-of-month.
+     * For example, from `2010-01-15` to `2011-03-18` is one year, two months and three days.
+     *
+     * The result of this method can be a negative period if the end is before the start.
+     * The negative sign will be the same in each of year, month and day.
+
+     * see {@link ChronoLocalDate.until}
+     *
+     * @param {LocalDate} startDate - the start date, inclusive, not null
+     * @param {LocalDate} endDate - the end date, exclusive, not null
+     * @return {Period} the period between this date and the end date, not null
+     */
+    static between(startDate, endDate) {
+        requireNonNull(startDate, 'startDate');
+        requireNonNull(endDate, 'endDate');
+        requireInstance(startDate, LocalDate, 'startDate');
+        requireInstance(endDate, LocalDate, 'endDate');
+        return startDate.until(endDate);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Obtains a {@link Period} from a text string such as {@link PnYnMnD}.
+     *
+     * This will parse the string produced by {@link toString} which is
+     * based on the ISO-8601 period formats {@link PnYnMnD} and {@link PnW}.
+     *
+     * The string starts with an optional sign, denoted by the ASCII negative
+     * or positive symbol. If negative, the whole period is negated.
+     * The ASCII letter 'P' is next in upper or lower case.
+     * There are then four sections, each consisting of a number and a suffix.
+     * At least one of the four sections must be present.
+     * The sections have suffixes in ASCII of 'Y', 'M', 'W' and 'D' for
+     * years, months, weeks and days, accepted in upper or lower case.
+     * The suffixes must occur in order.
+     * The number part of each section must consist of ASCII digits.
+     * The number may be prefixed by the ASCII negative or positive symbol.
+     * The number must parse to an `int`.
+     *
+     * The leading plus/minus sign, and negative values for other units are
+     * not part of the ISO-8601 standard. In addition, ISO-8601 does not
+     * permit mixing between the {@link PnYnMnD} and {@link PnW} formats.
+     * Any week-based input is multiplied by 7 and treated as a number of days.
+     *
+     * For example, the following are valid inputs:
+     * <pre>
+     *   'P2Y'             -- Period.ofYears(2)
+     *   'P3M'             -- Period.ofMonths(3)
+     *   'P4W'             -- Period.ofWeeks(4)
+     *   'P5D'             -- Period.ofDays(5)
+     *   'P1Y2M3D'         -- Period.of(1, 2, 3)
+     *   'P1Y2M3W4D'       -- Period.of(1, 2, 25)
+     *   'P-1Y2M'          -- Period.of(-1, 2, 0)
+     *   '-P1Y2M'          -- Period.of(-1, -2, 0)
+     * </pre>
+     *
+     * @param {string} text - the text to parse, not null
+     * @return {Period} the parsed period, not null
+     * @throws DateTimeParseException if the text cannot be parsed to a period
+     */
+    static parse(text) {
+        requireNonNull(text, 'text');
+        try {
+            return Period._parse(text);
+        } catch (ex){
+            if(ex instanceof ArithmeticException){
+                throw new DateTimeParseException('Text cannot be parsed to a Period', text, 0, ex);
+            } else {
+                throw ex;
+            }
+        }
+    }
+
+    /**
+     * because functions that containing a try/ catch block cant be optimized,
+     * we put the code in a sub function.
+     */
+    static _parse(text){
+        const matches = PATTERN.exec(text);
+        if (matches != null) {
+            const negate = '-' === matches[1] ? -1 : 1;
+            const yearMatch = matches[2];
+            const monthMatch = matches[3];
+            const weekMatch = matches[4];
+            const dayMatch = matches[5];
+            if (yearMatch != null || monthMatch != null || weekMatch != null || dayMatch != null) {
+                const years = Period._parseNumber(text, yearMatch, negate);
+                const months = Period._parseNumber(text, monthMatch, negate);
+                const weeks = Period._parseNumber(text, weekMatch, negate);
+                let days = Period._parseNumber(text, dayMatch, negate);
+                days = MathUtil.safeAdd(days, MathUtil.safeMultiply(weeks, 7));
+                return Period.create(years, months, days);
+            }
+        }
+        throw new DateTimeParseException('Text cannot be parsed to a Period', text, 0);
+    }
+
+    static _parseNumber(text, str, negate) {
+        if (str == null) {
+            return 0;
+        }
+        const val = MathUtil.parseInt(str);
+        return MathUtil.safeMultiply(val, negate);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Creates an instance.
+     *
+     * @param {number} years - the amount
+     * @param {number} months - the amount
+     * @param {number} days - the amount
+     * @return {Duration}
+     */
+    static create(years, months, days) {
+        return new Period(years, months, days);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Gets the list of units, from largest to smallest, that fully define this amount.
+     *
+     * @returns {ChronoUnit[]} list of units
+     */
+    units() {
+        return [ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS];
+    }
+
+    /**
+     * Gets the chronology that defines the meaning of the supported units.
+     *
+     * The period is defined by the chronology.
+     * It controls the supported units and restricts addition/subtraction
+     * to {@link ChronoLocalDate} instances of the same chronology.
+     *
+     * @return {IsoChronology} the chronology defining the period, not null
+     */
+    chronology() {
+        return IsoChronology.INSTANCE;
+    }
+
+    /**
+     * Gets the value of the requested unit.
+     *
+     * The supported units are chronology specific.
+     * They will typically be {@link ChronoUnit#YEARS},
+     * {@link ChronoUnit#MONTHS} and {@link ChronoUnit#DAYS}.
+     * Requesting an unsupported unit will throw an exception.
+     *
+     * @param {TemporalUnit} unit the {@link TemporalUnit} for which to return the value
+     * @return {number} the long value of the unit
+     * @throws DateTimeException if the unit is not supported
+     * @throws UnsupportedTemporalTypeException if the unit is not supported
+     */
+    get(unit) {
+        if (unit === ChronoUnit.YEARS) {
+            return this._years;
+        }
+        if (unit === ChronoUnit.MONTHS) {
+            return this._months;
+        }
+        if (unit === ChronoUnit.DAYS) {
+            return this._days;
+        }
+        throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Checks if all three units of this period are zero.
+     *
+     * A zero period has the value zero for the years, months and days units.
+     *
+     * @return {boolean} true if this period is zero-length
+     */
+    isZero() {
+        return (this === Period.ZERO);
+    }
+
+    /**
+     * Checks if any of the three units of this period are negative.
+     *
+     * This checks whether the years, months or days units are less than zero.
+     *
+     * @return {boolean} true if any unit of this period is negative
+     */
+    isNegative() {
+        return this._years < 0 || this._months < 0 || this._days < 0;
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Gets the amount of years of this period.
+     *
+     * This returns the years unit.
+     *
+     * The months unit is not normalized with the years unit.
+     * This means that a period of '15 months' is different to a period
+     * of '1 year and 3 months'.
+     *
+     * @return {number} the amount of years of this period, may be negative
+     */
+    years() {
+        return this._years;
+    }
+
+    /**
+     * Gets the amount of months of this period.
+     *
+     * This returns the months unit.
+     *
+     * The months unit is not normalized with the years unit.
+     * This means that a period of '15 months' is different to a period
+     * of '1 year and 3 months'.
+     *
+     * @return {number} the amount of months of this period, may be negative
+     */
+    months() {
+        return this._months;
+    }
+
+    /**
+     * Gets the amount of days of this period.
+     *
+     * This returns the days unit.
+     *
+     * @return {number} the amount of days of this period, may be negative
+     */
+    days() {
+        return this._days;
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Returns a copy of this period with the specified amount of years.
+     *
+     * This sets the amount of the years unit in a copy of this period.
+     * The months and days units are unaffected.
+     *
+     * The months unit is not normalized with the years unit.
+     * This means that a period of '15 months' is different to a period
+     * of '1 year and 3 months'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} years - the years to represent, may be negative
+     * @return {Period} a {@link Period} based on this period with the requested years, not null
+     */
+    withYears(years) {
+        if (years === this._years) {
+            return this;
+        }
+        return Period.create(years, this._months, this._days);
+    }
+
+    /**
+     * Returns a copy of this period with the specified amount of months.
+     *
+     * This sets the amount of the months unit in a copy of this period.
+     * The years and days units are unaffected.
+     *
+     * The months unit is not normalized with the years unit.
+     * This means that a period of '15 months' is different to a period
+     * of '1 year and 3 months'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} months - the months to represent, may be negative
+     * @return {Period} a {@link Period} based on this period with the requested months, not null
+     */
+    withMonths(months) {
+        if (months === this._months) {
+            return this;
+        }
+        return Period.create(this._years, months, this._days);
+    }
+
+    /**
+     * Returns a copy of this period with the specified amount of days.
+     *
+     * This sets the amount of the days unit in a copy of this period.
+     * The years and months units are unaffected.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} days - the days to represent, may be negative
+     * @return {Period} a {@link Period} based on this period with the requested days, not null
+     */
+    withDays(days) {
+        if (days === this._days) {
+            return this;
+        }
+        return Period.create(this._years, this._months, days);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Returns a copy of this period with the specified amount added.
+     *
+     * This input amount is converted to a {@link Period} using {@link from}.
+     * This operates separately on the years, months and days.
+     *
+     * For example, '1 year, 6 months and 3 days' plus '2 years, 2 months and 2 days'
+     * returns '3 years, 8 months and 5 days'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {TemporalAmount} amountToAdd - the period to add, not null
+     * @return {Period} a {@link Period} based on this period with the requested period added, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    plus(amountToAdd) {
+        const amount = Period.from(amountToAdd);
+        return Period.create(
+            MathUtil.safeAdd(this._years, amount._years),
+            MathUtil.safeAdd(this._months, amount._months),
+            MathUtil.safeAdd(this._days, amount._days));
+    }
+
+    /**
+     * Returns a copy of this period with the specified years added.
+     *
+     * This adds the amount to the years unit in a copy of this period.
+     * The months and days units are unaffected.
+     * For example, '1 year, 6 months and 3 days' plus 2 years returns '3 years, 6 months and 3 days'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} yearsToAdd - the years to add, positive or negative
+     * @return {Period} a {@link Period} based on this period with the specified years added, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    plusYears(yearsToAdd) {
+        if (yearsToAdd === 0) {
+            return this;
+        }
+        return Period.create(MathUtil.safeToInt(MathUtil.safeAdd(this._years, yearsToAdd)), this._months, this._days);
+    }
+
+    /**
+     * Returns a copy of this period with the specified months added.
+     *
+     * This adds the amount to the months unit in a copy of this period.
+     * The years and days units are unaffected.
+     * For example, '1 year, 6 months and 3 days' plus 2 months returns '1 year, 8 months and 3 days'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} monthsToAdd - the months to add, positive or negative
+     * @return {Period} a {@link Period} based on this period with the specified months added, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    plusMonths(monthsToAdd) {
+        if (monthsToAdd === 0) {
+            return this;
+        }
+        return Period.create(this._years, MathUtil.safeToInt(MathUtil.safeAdd(this._months, monthsToAdd)), this._days);
+    }
+
+    /**
+     * Returns a copy of this period with the specified days added.
+     *
+     * This adds the amount to the days unit in a copy of this period.
+     * The years and months units are unaffected.
+     * For example, '1 year, 6 months and 3 days' plus 2 days returns '1 year, 6 months and 5 days'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} daysToAdd - the days to add, positive or negative
+     * @return {Period} a {@link Period} based on this period with the specified days added, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    plusDays(daysToAdd) {
+        if (daysToAdd === 0) {
+            return this;
+        }
+        return Period.create(this._years, this._months, MathUtil.safeToInt(MathUtil.safeAdd(this._days, daysToAdd)));
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Returns a copy of this period with the specified amount subtracted.
+     *
+     * This input amount is converted to a {@link Period} using {@link from}.
+     * This operates separately on the years, months and days.
+     *
+     * For example, '1 year, 6 months and 3 days' minus '2 years, 2 months and 2 days'
+     * returns '-1 years, 4 months and 1 day'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {TemporalAmount} amountToSubtract - the period to subtract, not null
+     * @return {Period} a {@link Period} based on this period with the requested period subtracted, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    minus(amountToSubtract) {
+        const amount = Period.from(amountToSubtract);
+        return Period.create(
+            MathUtil.safeSubtract(this._years, amount._years),
+            MathUtil.safeSubtract(this._months, amount._months),
+            MathUtil.safeSubtract(this._days, amount._days));
+    }
+
+    /**
+     * Returns a copy of this period with the specified years subtracted.
+     *
+     * This subtracts the amount from the years unit in a copy of this period.
+     * The months and days units are unaffected.
+     * For example, '1 year, 6 months and 3 days' minus 2 years returns '-1 years, 6 months and 3 days'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} yearsToSubtract - the years to subtract, positive or negative
+     * @return {Period} a {@link Period} based on this period with the specified years subtracted, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    minusYears(yearsToSubtract) {
+        return this.plusYears(-1 * yearsToSubtract);
+    }
+
+    /**
+     * Returns a copy of this period with the specified months subtracted.
+     *
+     * This subtracts the amount from the months unit in a copy of this period.
+     * The years and days units are unaffected.
+     * For example, '1 year, 6 months and 3 days' minus 2 months returns '1 year, 4 months and 3 days'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} monthsToSubtract - the years to subtract, positive or negative
+     * @return {Period} a {@link Period} based on this period with the specified months subtracted, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    minusMonths(monthsToSubtract) {
+        return this.plusMonths(-1 * monthsToSubtract);
+    }
+
+    /**
+     * Returns a copy of this period with the specified days subtracted.
+     *
+     * This subtracts the amount from the days unit in a copy of this period.
+     * The years and months units are unaffected.
+     * For example, '1 year, 6 months and 3 days' minus 2 days returns '1 year, 6 months and 1 day'.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {number} daysToSubtract - the months to subtract, positive or negative
+     * @return {Period} a {@link Period} based on this period with the specified days subtracted, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    minusDays(daysToSubtract) {
+        return this.plusDays(-1 * daysToSubtract);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Returns a new instance with each element in this period multiplied
+     * by the specified scalar.
+     *
+     * This simply multiplies each field, years, months, days and normalized time,
+     * by the scalar. No normalization is performed.
+     *
+     * @param {number} scalar - the scalar to multiply by, not null
+     * @return {Period} a {@link Period} based on this period with the amounts multiplied by the scalar, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    multipliedBy(scalar) {
+        if (this === Period.ZERO || scalar === 1) {
+            return this;
+        }
+        return Period.create(
+            MathUtil.safeMultiply(this._years, scalar),
+            MathUtil.safeMultiply(this._months, scalar),
+            MathUtil.safeMultiply(this._days, scalar));
+    }
+
+    /**
+     * Returns a new instance with each amount in this period negated.
+     *
+     * @return {Period} a {@link Period} based on this period with the amounts negated, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    negated() {
+        return this.multipliedBy(-1);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Returns a copy of this period with the years and months normalized
+     * using a 12 month year.
+     *
+     * This normalizes the years and months units, leaving the days unit unchanged.
+     * The months unit is adjusted to have an absolute value less than 11,
+     * with the years unit being adjusted to compensate. For example, a period of
+     * '1 Year and 15 months' will be normalized to '2 years and 3 months'.
+     *
+     * The sign of the years and months units will be the same after normalization.
+     * For example, a period of '1 year and -25 months' will be normalized to
+     * '-1 year and -1 month'.
+     *
+     * This normalization uses a 12 month year which is not valid for all calendar systems.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @return {Period} a {@link Period} based on this period with excess months normalized to years, not null
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    normalized() {
+        const totalMonths = this.toTotalMonths();
+        const splitYears = MathUtil.intDiv(totalMonths, 12);
+        const splitMonths = MathUtil.intMod(totalMonths, 12);  // no overflow
+        if (splitYears === this._years && splitMonths === this._months) {
+            return this;
+        }
+        return Period.create(MathUtil.safeToInt(splitYears), splitMonths, this._days);
+    }
+
+    /**
+     * Gets the total number of months in this period using a 12 month year.
+     *
+     * This returns the total number of months in the period by multiplying the
+     * number of years by 12 and adding the number of months.
+     *
+     * This uses a 12 month year which is not valid for all calendar systems.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @return {number} the total number of months in the period, may be negative
+     */
+    toTotalMonths() {
+        return this._years * 12 + this._months;  // no overflow
+    }
+
+    //-------------------------------------------------------------------------
+    /**
+     * Adds this period to the specified temporal object.
+     *
+     * This returns a temporal object of the same observable type as the input
+     * with this period added.
+     *
+     * In most cases, it is clearer to reverse the calling pattern by using
+     * {@link Temporal#plus}.
+     * <pre>
+     *   // these two lines are equivalent, but the second approach is recommended
+     *   dateTime = thisPeriod.addTo(dateTime);
+     *   dateTime = dateTime.plus(thisPeriod);
+     * </pre>
+     *
+     * The calculation will add the years, then months, then days.
+     * Only non-zero amounts will be added.
+     * If the date-time has a calendar system with a fixed number of months in a
+     * year, then the years and months will be combined before being added.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {Temporal} temporal - the temporal object to adjust, not null
+     * @return {Temporal} an object of the same type with the adjustment made, not null
+     * @throws DateTimeException if unable to add
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    addTo(temporal) {
+        requireNonNull(temporal, 'temporal');
+        if (this._years !== 0) {
+            if (this._months !== 0) {
+                temporal = temporal.plus(this.toTotalMonths(), ChronoUnit.MONTHS);
+            } else {
+                temporal = temporal.plus(this._years, ChronoUnit.YEARS);
+            }
+        } else if (this._months !== 0) {
+            temporal = temporal.plus(this._months, ChronoUnit.MONTHS);
+        }
+        if (this._days !== 0) {
+            temporal = temporal.plus(this._days, ChronoUnit.DAYS);
+        }
+        return temporal;
+    }
+
+    /**
+     * Subtracts this period from the specified temporal object.
+     *
+     * This returns a temporal object of the same observable type as the input
+     * with this period subtracted.
+     *
+     * In most cases, it is clearer to reverse the calling pattern by using
+     * {@link Temporal#minus}.
+     * <pre>
+     *   // these two lines are equivalent, but the second approach is recommended
+     *   dateTime = thisPeriod.subtractFrom(dateTime);
+     *   dateTime = dateTime.minus(thisPeriod);
+     * </pre>
+     *
+     * The calculation operates as follows.
+     * First, the chronology of the temporal is checked to ensure it is ISO chronology or null.
+     * Second, if the months are zero, the years are added if non-zero, otherwise
+     * the combination of years and months is added if non-zero.
+     * Finally, any days are added.
+     *
+     * The calculation will subtract the years, then months, then days.
+     * Only non-zero amounts will be subtracted.
+     * If the date-time has a calendar system with a fixed number of months in a
+     * year, then the years and months will be combined before being subtracted.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param {Temporal} temporal - the temporal object to adjust, not null
+     * @return {Temporal} an object of the same type with the adjustment made, not null
+     * @throws DateTimeException if unable to subtract
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    subtractFrom(temporal) {
+        requireNonNull(temporal, 'temporal');
+        if (this._years !== 0) {
+            if (this._months !== 0) {
+                temporal = temporal.minus(this.toTotalMonths(), ChronoUnit.MONTHS);
+            } else {
+                temporal = temporal.minus(this._years, ChronoUnit.YEARS);
+            }
+        } else if (this._months !== 0) {
+            temporal = temporal.minus(this._months, ChronoUnit.MONTHS);
+        }
+        if (this._days !== 0) {
+            temporal = temporal.minus(this._days, ChronoUnit.DAYS);
+        }
+        return temporal;
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Checks if this period is equal to another period.
+     *
+     * The comparison is based on the amounts held in the period.
+     * To be equal, the years, months and days units must be individually equal.
+     * Note that this means that a period of '15 Months' is not equal to a period
+     * of '1 Year and 3 Months'.
+     *
+     * @param {*} obj - the object to check, null returns false
+     * @return {boolean} true if this is equal to the other period
+     */
+    equals(obj) {
+        if (this === obj) {
+            return true;
+        }
+        if (obj instanceof Period) {
+            const other = obj;
+            return this._years === other._years &&
+                this._months === other._months &&
+                this._days === other._days;
+        }
+        return false;
+    }
+
+    /**
+     * A hash code for this period.
+     *
+     * @return {number} a suitable hash code
+     */
+    hashCode() {
+        return MathUtil.hashCode(this._years, this._months, this._days);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Outputs this period as a string, such as {@link P6Y3M1D}.
+     *
+     * The output will be in the ISO-8601 period format.
+     * A zero period will be represented as zero days, 'P0D'.
+     *
+     * @return {string} a string representation of this period, not null
+     */
+    toString() {
+        if (this === Period.ZERO) {
+            return 'P0D';
+        } else {
+            let buf = 'P';
+            if (this._years !== 0) {
+                buf += '' + this._years + 'Y';
+            }
+            if (this._months !== 0) {
+                buf += '' + this._months + 'M';
+            }
+            if (this._days !== 0) {
+                buf += '' + this._days + 'D';
+            }
+            return buf;
+        }
+    }
+
+    /**
+     *
+     * @return {string} same as {@link Period.toString}
+     */
+    toJSON() {
+        return this.toString();
+    }
+}
+
+export function _init() {
+    /**
+     * A constant for a period of zero.
+     */
+    Period.ofDays(0);
+}