{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap dc6f870a56cbfdf649e4","webpack:///./src/js-joda.js","webpack:///./src/Clock.js","webpack:///./src/Instant.js","webpack:///./src/temporal/ChronoField.js","webpack:///./src/MathUtil.js","webpack:///./src/errors.js","webpack:///./~/es6-error/dist/index.js","webpack:///./src/temporal/ChronoUnit.js","webpack:///./src/Duration.js","webpack:///./src/assert.js","webpack:///./src/temporal/TemporalAmount.js","webpack:///./src/LocalTime.js","webpack:///./src/format/DateTimeFormatter.js","webpack:///./src/format/ParsePosition.js","webpack:///./src/format/DateTimeParseContext.js","webpack:///./src/format/DateTimeBuilder.js","webpack:///./src/format/EnumMap.js","webpack:///./src/chrono/IsoChronology.js","webpack:///./src/Enum.js","webpack:///./src/LocalDate.js","webpack:///./src/chrono/ChronoLocalDate.js","webpack:///./src/temporal/TemporalQueries.js","webpack:///./src/ZoneOffset.js","webpack:///./src/temporal/TemporalAccessor.js","webpack:///./src/DayOfWeek.js","webpack:///./src/format/DateTimeFormatterBuilder.js","webpack:///./src/format/DecimalStyle.js","webpack:///./src/format/SignStyle.js","webpack:///./src/format/ResolverStyle.js","webpack:///./src/Month.js","webpack:///./src/Period.js","webpack:///./src/Year.js","webpack:///./src/temporal/TemporalField.js","webpack:///./src/temporal/ValueRange.js","webpack:///./src/_init.js"],"names":[],"mappings":"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","file":"js-joda.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"JSJoda\"] = factory();\n\telse\n\t\troot[\"JSJoda\"] = factory();\n})(this, function() {\nreturn \n\n\n/** WEBPACK FOOTER **\n ** webpack/universalModuleDefinition\n **/"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap dc6f870a56cbfdf649e4\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nexport { Clock } from './Clock';\nexport { Duration } from './Duration';\nexport { DateTimeException, DateTimeParseException } from './errors';\nexport { Instant } from './Instant';\nexport { LocalDate } from './LocalDate';\nexport { LocalTime } from './LocalTime';\nexport { MathUtil } from './MathUtil';\nexport { Month } from './Month';\nexport { Period } from './Period';\nexport { Year } from './Year';\nexport { ZoneOffset } from './ZoneOffset';\n\nimport './_init';\n\n\n/** WEBPACK FOOTER **\n ** ./src/js-joda.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {Instant} from './Instant';\nimport {ZoneOffset} from './ZoneOffset';\n\n/**\n * A clock providing access to the current instant, date and time using a time-zone.\n *
\n * Instances of this class are used to find the current instant, which can be\n * interpreted using the stored time-zone to find the current date and time.\n * As such, a clock can be used instead of {@link System#currentTimeMillis()}\n * and {@link TimeZone#getDefault()}.\n *
\n * Use of a {@code Clock} is optional. All key date-time classes also have a\n * {@code now()} factory method that uses the system clock in the default time zone.\n * The primary purpose of this abstraction is to allow alternate clocks to be\n * plugged in as and when required. Applications use an object to obtain the\n * current time rather than a static method. This can simplify testing.\n *
\n * Best practice for applications is to pass a {@code Clock} into any method\n * that requires the current instant.\n *\n * This approach allows an alternate clock, such as {@link #fixed(Instant, ZoneId) fixed}\n * or {@link #offset(Clock, Duration) offset} to be used during testing.\n *
\n * The {@code system} factory methods provide clocks based on the best available\n * system clock This may use {@link System#currentTimeMillis()}, or a higher\n * resolution clock if one is available.\n */\n\n/**\n * The javascript Clock implementation differs from the openjdk.\n *\n * Javascript only provides the UTC millis of epoch and the ZoneOffset in minutes of the system default time.\n * Javascript do not provide the system default ZoneId.\n *\n * the system default ZoneId is only guessable by the ZoneOffset, like moment-timezone does by returning one ZoneId\n * with the same ZoneOffset.\n *\n * Therefore we are doing a shortcut here, by defining a SystemUTCClock and a SystemDefaultClock, the Clock itself\n * is returning the ZoneOffset and not the ZoneRules as in the jdk. We should change it, when introducing the iana\n * timezone database and implementing the timezone domains.\n *\n */\n\nexport class Clock {\n /**\n * Obtains a clock that returns the current instant using the\n * system clock, converting to date and time using the Date.getTime() UTC millis.\n *
\n * This clock, rather than {@link #systemDefaultZone()}, should be used when\n * you need the current instant without the date or time.\n *
\n * @return a clock that uses the system clock in the UTC zone, not null\n */\n static systemUTC() {\n return new SystemUTCClock();\n }\n\n /**\n * Obtains a clock that returns the current instant using the best available\n * system clock, converting to date and time using the default time-zone.\n *
\n * This clock is based on the available system clock using the Date.getTime() UTC millis\n *
\n * Using this method hard codes a dependency to the default time-zone into your application.\n *\n * The {@link #systemUTC() UTC clock} should be used when you need the current instant\n * without the date or time.\n *
\n *\n * @return a clock that uses the system clock in the default zone, not null\n * @see ZoneId#systemDefault()\n */\n static systemDefaultZone() {\n return new SystemDefaultClock();\n }\n\n /**\n * Obtains a clock that always returns the same instant.\n *
\n * This clock simply returns the specified instant.\n * As such, it is not a clock in the conventional sense.\n * The main use case for this is in testing, where the fixed clock ensures\n * tests are not dependent on the current clock.\n *\n * @param fixedInstant the instant to use as the clock, not null\n * @param zoneOffset the zoneOffset to use as zone Offset, not null\n * @return a clock that always returns the same instant, not null\n */\n static fixed(fixedInstant, zoneOffset) {\n return new FixedClock(fixedInstant, zoneOffset);\n }\n\n /**\n * Gets the current millisecond instant of the clock.\n *
\n * This returns the millisecond-based instant, measured from 1970-01-01T00:00Z (UTC).\n * This is equivalent to the definition of {@link Date#getTime()}.\n *
\n * Most applications should avoid this method and use {@link Instant} to represent\n * an instant on the time-line rather than a raw millisecond value.\n * This method is provided to allow the use of the clock in high performance use cases\n * where the creation of an object would be unacceptable.\n *
\n * The default implementation currently calls {@link #instant}.\n *\n * @return the current millisecond instant from this clock, measured from\n * the Java epoch of 1970-01-01T00:00Z (UTC), not null\n */\n millis(){\n throw new TypeError('millis() function is not implemented');\n }\n\n /**\n * Gets the current instant of the clock.\n *
\n * This returns an instant representing the current instant as defined by the clock.\n *\n * @return the current instant from this clock, not null\n */\n instant(){\n throw new TypeError('instant() function is not implemented');\n }\n\n /**\n * in opposite to the jdk implementation the Clock itself returns the offset, that is because\n * javascript provides only the UTC and the \"local\" (system default time zone.\n * it is not possible the get the system default ZoneId without guessing. If we would define ZoneRules, we had to\n * define something like a virtual, not standard ZoneId like \"SystemDefault\".\n * Until we to not have a tzdb, we leave this question open\n */\n offset(){\n throw new TypeError('offset() function is not implemented');\n }\n}\n\nclass SystemClock extends Clock {\n millis() {\n return new Date().getTime();\n }\n\n instant() {\n return Instant.ofEpochMilli(this.millis());\n }\n\n offset() {\n return ZoneOffset.ofTotalSeconds(0);\n }\n}\n\n/**\n * Implementation of a clock that always returns the latest time from\n * {@link Date#getTime()}.\n */\nclass SystemUTCClock extends SystemClock{\n toString(){\n return 'SystemClock[UTC]';\n }\n}\n\n/**\n * Implementation of a clock that always returns the latest time from\n * sytem default Zone {@link Date#getTime()} and {@link Date#getTimeZoneOffset()}.\n */\nclass SystemDefaultClock extends SystemClock{\n offset(instant) {\n var offsetInMinutes = new Date().getTimezoneOffset(instant.epochMilli());\n return ZoneOffset.ofTotalMinutes(offsetInMinutes);\n }\n\n toString(){\n return 'SystemClock[default]';\n }\n}\n\n/**\n * Implementation of a clock that always returns the same instant.\n * This is typically used for testing.\n */\nclass FixedClock extends Clock{\n constructor(fixedInstant, zoneOffset) {\n super();\n this._instant = fixedInstant;\n this._zoneOffset = zoneOffset;\n }\n\n instant() {\n return this._instant;\n }\n\n offset() {\n return this._zoneOffset;\n }\n\n toString(){\n return 'FixedClock[]';\n }\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/Clock.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {ChronoField} from './temporal/ChronoField';\nimport {ChronoUnit} from './temporal/ChronoUnit';\nimport {Clock} from './Clock';\nimport {DateTimeException, UnsupportedTemporalTypeException} from './errors';\nimport {LocalTime} from './LocalTime';\nimport {MathUtil} from './MathUtil';\nimport {TemporalAccessor} from './temporal/TemporalAccessor';\n\n// TODO verify the arbitrary values for min/ max seconds, set to 999_999 Years for now\nconst MIN_SECONDS = -31619087596800; // -999999-01-01T00:00:00\nconst MAX_SECONDS = 31494784780799; // +999999-12-31T23:59:59\nconst NANOS_PER_MILLI = 1000000;\n\n/**\n * An instantaneous point on the time-line.\n * \n * This class models a single instantaneous point on the time-line.\n * This might be used to record event time-stamps in the application.\n * \n * Time-scale\n * \n * The length of the solar day is the standard way that humans measure time.\n * This has traditionally been subdivided into 24 hours of 60 minutes of 60 seconds,\n * forming a 86400 second day.\n * \n * Modern timekeeping is based on atomic clocks which precisely define an SI second\n * relative to the transitions of a Caesium atom. The length of an SI second was defined\n * to be very close to the 86400th fraction of a day.\n * \n * Unfortunately, as the Earth rotates the length of the day varies.\n * In addition, over time the average length of the day is getting longer as the Earth slows.\n * As a result, the length of a solar day in 2012 is slightly longer than 86400 SI seconds.\n * The actual length of any given day and the amount by which the Earth is slowing\n * are not predictable and can only be determined by measurement.\n * The UT1 time-scale captures the accurate length of day, but is only available some\n * time after the day has completed.\n * \n * The UTC time-scale is a standard approach to bundle up all the additional fractions\n * of a second from UT1 into whole seconds, known as leap-seconds.\n * A leap-second may be added or removed depending on the Earth's rotational changes.\n * As such, UTC permits a day to have 86399 SI seconds or 86401 SI seconds where\n * necessary in order to keep the day aligned with the Sun.\n * \n * The modern UTC time-scale was introduced in 1972, introducing the concept of whole leap-seconds.\n * Between 1958 and 1972, the definition of UTC was complex, with minor sub-second leaps and\n * alterations to the length of the notional second. As of 2012, discussions are underway\n * to change the definition of UTC again, with the potential to remove leap seconds or\n * introduce other changes.\n * \n * Given the complexity of accurate timekeeping described above, this Java API defines\n * its own time-scale, the Java Time-Scale.\n * \n * The Java Time-Scale divides each calendar day into exactly 86400\n * subdivisions, known as seconds. These seconds may differ from the\n * SI second. It closely matches the de facto international civil time\n * scale, the definition of which changes from time to time.\n * \n * The Java Time-Scale has slightly different definitions for different\n * segments of the time-line, each based on the consensus international\n * time scale that is used as the basis for civil time. Whenever the\n * internationally-agreed time scale is modified or replaced, a new\n * segment of the Java Time-Scale must be defined for it. Each segment\n * must meet these requirements:\n *
\n * This instance is immutable and unaffected by this method call.\n *\n * @param secondsToAdd the seconds to add, positive or negative\n * @param nanosToAdd the nanos to add, positive or negative\n * @return an {@code Instant} based on this instant with the specified seconds added, not null\n * @throws DateTimeException if the result exceeds the maximum or minimum instant\n */\n _plus(secondsToAdd, nanosToAdd) {\n if ((secondsToAdd | nanosToAdd) === 0) {\n return this;\n }\n var epochSec = this._seconds + secondsToAdd;\n epochSec = epochSec + MathUtil.intDiv(nanosToAdd, LocalTime.NANOS_PER_SECOND);\n var _nanosToAdd = nanosToAdd % LocalTime.NANOS_PER_SECOND;\n var nanoAdjustment = this._nanos + _nanosToAdd;\n return Instant.ofEpochSecond(epochSec, nanoAdjustment);\n }\n\n /**\n * Checks if this instant is equal to the specified instant.\n *
\n * The comparison is based on the time-line position of the instants.\n *\n * @param otherInstant the other instant, null/ undefined returns false\n * @return true if the other instant is equal to this one\n */\n equals(otherInstant) {\n if(this === otherInstant){\n return true;\n }\n if(otherInstant instanceof Instant){\n return this.epochSecond() === otherInstant.epochSecond() &&\n this.nano() === otherInstant.nano();\n }\n return false;\n }\n \n /**\n * Calculates the period between this instant and another instant in\n * terms of the specified unit.\n *
\n * This calculates the period between two instants in terms of a single unit.\n * The start and end points are {@code this} and the specified instant.\n * The result will be negative if the end is before the start.\n * The calculation returns a whole number, representing the number of\n * complete units between the two instants.\n * The {@code Temporal} passed to this method is converted to a\n * {@code Instant} using {@link #from(TemporalAccessor)}.\n * For example, the period in days between two dates can be calculated\n * using {@code startInstant.until(endInstant, SECONDS)}.\n *
\n * This method operates in association with {@link TemporalUnit#between}.\n * The result of this method is a {@code long} representing the amount of\n * the specified unit. By contrast, the result of {@code between} is an\n * object that can be used directly in addition/subtraction:\n *
\n * long period = start.until(end, SECONDS); // this method\n * dateTime.plus(SECONDS.between(start, end)); // use in plus/minus\n *\n *
\n * The calculation is implemented in this method for {@link ChronoUnit}.\n * The units {@code NANOS}, {@code MICROS}, {@code MILLIS}, {@code SECONDS},\n * {@code MINUTES}, {@code HOURS}, {@code HALF_DAYS} and {@code DAYS}\n * are supported. Other {@code ChronoUnit} values will throw an exception.\n *
\n * If the unit is not a {@code ChronoUnit}, then the result of this method\n * is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)}\n * passing {@code this} as the first argument and the input temporal as\n * the second argument.\n *
\n * This instance is immutable and unaffected by this method call.\n *\n * @param {Temporal} endExclusive the end date, which is converted to an {@code Instant}, not null\n * @param {TemporalUnit} unit the unit to measure the period in, not null\n * @return {Number} the amount of the period between this date and the end date\n * @throws DateTimeException if the period cannot be calculated\n * @throws ArithmeticException if numeric overflow occurs\n */\n until(endExclusive, unit) {\n let end = Instant.from(endExclusive);\n if (unit instanceof ChronoUnit) {\n switch (unit) {\n case ChronoUnit.NANOS: return this._nanosUntil(end);\n case ChronoUnit.MICROS: return this._nanosUntil(end) / 1000;\n case ChronoUnit.MILLIS: return MathUtil.safeSubtract(end.toEpochMilli(), this.toEpochMilli());\n case ChronoUnit.SECONDS: return this._secondsUntil(end);\n case ChronoUnit.MINUTES: return MathUtil.intDiv(this._secondsUntil(end), LocalTime.SECONDS_PER_MINUTE);\n case ChronoUnit.HOURS: return MathUtil.intDiv(this._secondsUntil(end), LocalTime.SECONDS_PER_HOUR);\n case ChronoUnit.HALF_DAYS: return MathUtil.intDiv(this._secondsUntil(end), (12 * LocalTime.SECONDS_PER_HOUR));\n case ChronoUnit.DAYS: return MathUtil.intDiv(this._secondsUntil(end), LocalTime.SECONDS_PER_DAY);\n }\n throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);\n }\n return unit.between(this, end);\n }\n\n _nanosUntil(end) {\n let secsDiff = MathUtil.safeSubtract(end.epochSecond(), this.epochSecond());\n let totalNanos = MathUtil.safeMultiply(secsDiff, LocalTime.NANOS_PER_SECOND);\n return MathUtil.safeAdd(totalNanos, end.nano() - this.nano());\n }\n\n _secondsUntil(end) {\n let secsDiff = MathUtil.safeSubtract(end.epochSecond(), this.epochSecond());\n let nanosDiff = end.nano() - this.nano();\n if (secsDiff > 0 && nanosDiff < 0) {\n secsDiff--;\n } else if (secsDiff < 0 && nanosDiff > 0) {\n secsDiff++;\n }\n return secsDiff;\n }\n\n /**\n * Gets the value of the specified field from this instant as an {@code int}.\n *
\n * This queries this instant for the value for the specified field.\n * The returned value will always be within the valid range of values for the field.\n * If it is not possible to return the value, because the field is not supported\n * or for some other reason, an exception is thrown.\n *
\n * If the field is a {@link ChronoField} then the query is implemented here.\n * The {@link #isSupported(TemporalField) supported fields} will return valid\n * values based on this date-time, except {@code INSTANT_SECONDS} which is too\n * large to fit in an {@code int} and throws a {@code DateTimeException}.\n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n *
\n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}\n * passing {@code this} as the argument. Whether the value can be obtained,\n * and what the value represents, is determined by the field.\n *\n * @param {TemporalField} field the field to get, not null\n * @return {Number} the value for the field\n * @throws DateTimeException if a value for the field cannot be obtained\n * @throws ArithmeticException if numeric overflow occurs\n */\n get(field) {\n if (field instanceof ChronoField) {\n switch (field) {\n case ChronoField.NANO_OF_SECOND: return this._nanos;\n case ChronoField.MICRO_OF_SECOND: return MathUtil.intDiv(this._nanos, 1000);\n case ChronoField.MILLI_OF_SECOND: return MathUtil.intDiv(this._nanos, NANOS_PER_MILLI);\n case ChronoField.INSTANT_SECONDS:\n ChronoField.INSTANT_SECONDS.checkValidIntValue(this._seconds);\n }\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n return this.range(field).checkValidIntValue(field.getFrom(this), field);\n }\n\n /**\n * Gets the value of the specified field from this instant as a {@code long}.\n *
\n * This queries this instant for the value for the specified field.\n * If it is not possible to return the value, because the field is not supported\n * or for some other reason, an exception is thrown.\n *
\n * If the field is a {@link ChronoField} then the query is implemented here.\n * The {@link #isSupported(TemporalField) supported fields} will return valid\n * values based on this date-time.\n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n *
\n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}\n * passing {@code this} as the argument. Whether the value can be obtained,\n * and what the value represents, is determined by the field.\n *\n * @param {TemporalField} field the field to get, not null\n * @return {Number} the value for the field\n * @throws DateTimeException if a value for the field cannot be obtained\n * @throws ArithmeticException if numeric overflow occurs\n */\n getLong(field) {\n if (field instanceof ChronoField) {\n switch (field) {\n case ChronoField.NANO_OF_SECOND: return this._nanos;\n case ChronoField.MICRO_OF_SECOND: return MathUtil.intDiv(this._nanos, 1000);\n case ChronoField.MILLI_OF_SECOND: return MathUtil.intDiv(this._nanos, NANOS_PER_MILLI);\n case ChronoField.INSTANT_SECONDS: return this._seconds;\n }\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n return field.getFrom(this);\n }\n \n /**\n * Checks if the specified field is supported.\n *
\n * This checks if this instant can be queried for the specified field.\n * If false, then calling the {@link #range(TemporalField) range} and\n * {@link #get(TemporalField) get} methods will throw an exception.\n *
\n * If the field is a {@link ChronoField} then the query is implemented here.\n * The supported fields are:\n *
\n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}\n * passing {@code this} as the argument.\n * Whether the field is supported is determined by the field.\n *\n * @param {TemporalField, TemporalUnit} fieldOrUnit the field to check, null returns false\n * @return true if the field is supported on this instant, false if not\n */\n isSupported(fieldOrUnit) {\n if (fieldOrUnit instanceof ChronoField) {\n return fieldOrUnit === ChronoField.INSTANT_SECONDS || fieldOrUnit === ChronoField.NANO_OF_SECOND || fieldOrUnit === ChronoField.MICRO_OF_SECOND || fieldOrUnit === ChronoField.MILLI_OF_SECOND;\n }\n if (fieldOrUnit instanceof ChronoUnit) {\n return fieldOrUnit.isTimeBased() || fieldOrUnit === ChronoUnit.DAYS;\n }\n return fieldOrUnit != null && fieldOrUnit.isSupportedBy(this);\n }\n\n /**\n * Obtains an instance of {@code Instant} from a temporal object.\n *
\n * A {@code TemporalAccessor} represents some form of date and time information.\n * This factory converts the arbitrary temporal object to an instance of {@code Instant}.\n *
\n * The conversion extracts the {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS}\n * and {@link ChronoField#NANO_OF_SECOND NANO_OF_SECOND} fields.\n *
\n * This method matches the signature of the functional interface {@link TemporalQuery}\n * allowing it to be used as a query via method reference, {@code Instant::from}.\n *\n * @param {TemporalAccessor} temporal the temporal object to convert, not null\n * @return {Instant} the instant, not null\n * @throws DateTimeException if unable to convert to an {@code Instant}\n */\n static from(temporal) {\n try {\n let instantSecs = temporal.getLong(ChronoField.INSTANT_SECONDS);\n let nanoOfSecond = temporal.get(ChronoField.NANO_OF_SECOND);\n return Instant.ofEpochSecond(instantSecs, nanoOfSecond);\n } catch (ex) {\n throw new DateTimeException('Unable to obtain Instant from TemporalAccessor: ' +\n temporal + ', type ' + typeof temporal, ex);\n }\n }\n\n /**\n * Obtains an instance of {@code Instant} using seconds from the\n * epoch of 1970-01-01T00:00:00Z.\n *\n * @param epochSecond the number of seconds from 1970-01-01T00:00:00Z\n * @param nanoAdjustment nanoseconds start from the start of epochSecond, if null the nanosecond field is set to zero.\n * @return an instant, not null\n * @throws DateTimeException if the instant exceeds the maximum or minimum instant\n */\n static ofEpochSecond(epochSecond, nanoAdjustment=0){\n var secs = epochSecond + MathUtil.floorDiv(nanoAdjustment, LocalTime.NANOS_PER_SECOND);\n var nos = MathUtil.floorMod(nanoAdjustment, LocalTime.NANOS_PER_SECOND);\n return Instant._create(secs, nos);\n }\n\n /**\n * Obtains an instance of {@code Instant} using milliseconds from the\n * epoch of 1970-01-01T00:00:00Z.\n *
\n * The seconds and nanoseconds are extracted from the specified milliseconds.\n *\n * @param epochMilli the number of milliseconds from 1970-01-01T00:00:00Z\n * @return an instant, not null\n * @throws DateTimeException if the instant exceeds the maximum or minimum instant\n */\n static ofEpochMilli(epochMilli) {\n var secs = MathUtil.floorDiv(epochMilli, 1000);\n var mos = MathUtil.floorMod(epochMilli, 1000);\n return Instant._create(secs, mos * 1000000);\n }\n\n static _create(seconds, nanoOfSecond){\n if(seconds === 0 && nanoOfSecond === 0){\n return Instant.EPOCH;\n }\n return new Instant(seconds, nanoOfSecond);\n }\n\n static validate(seconds, nanoOfSecond){\n if (seconds < MIN_SECONDS || seconds > MAX_SECONDS) {\n throw new DateTimeException('Instant exceeds minimum or maximum instant');\n }\n }\n}\n\nexport function _init() {\n Instant.EPOCH = new Instant(0, 0);\n Instant.MIN = Instant.ofEpochSecond(MIN_SECONDS, 0);\n Instant.MAX = Instant.ofEpochSecond(MAX_SECONDS, 999999999);\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/Instant.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {MAX_SAFE_INTEGER, MIN_SAFE_INTEGER} from '../MathUtil';\nimport {ChronoUnit} from './ChronoUnit';\nimport { TemporalField } from './TemporalField';\nimport { ValueRange } from './ValueRange';\nimport {Year} from '../Year';\n\nexport class ChronoField extends TemporalField {\n\n constructor(name, baseUnit, rangeUnit, range) {\n super();\n this._name = name;\n this._baseUnit = baseUnit;\n this._rangeUnit = rangeUnit;\n this._range = range;\n } \n\n name(){\n return this._name; \n }\n \n baseUnit(){\n return this._baseUnit; \n }\n \n rangeUnit(){\n return this._rangeUnit; \n }\n \n range(){\n return this._range; \n }\n \n displayName(){\n return this.toString(); \n }\n \n checkValidValue(value) {\n return this.range().checkValidValue(value, this.name());\n }\n\n /**\n * Checks if this field represents a component of a date.\n *\n * @return true if it is a component of a date\n */\n isDateBased() {\n var dateBased =\n //this === ChronoField.DAY_OF_WEEK ||\n //this === ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH ||\n //this === ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR ||\n this === ChronoField.DAY_OF_MONTH ||\n this === ChronoField.DAY_OF_YEAR ||\n this === ChronoField.EPOCH_DAY ||\n //this === ChronoField.ALIGNED_WEEK_OF_MONTH ||\n //this === ChronoField.ALIGNED_WEEK_OF_YEAR ||\n this === ChronoField.MONTH_OF_YEAR ||\n //this === ChronoField.EPOCH_MONTH ||\n //this === ChronoField.YEAR_OF_ERA ||\n this === ChronoField.YEAR ||\n this === ChronoField.ERA;\n return dateBased;\n }\n\n /**\n * Get the range of valid values for this field using the temporal object to\n * refine the result.\n *
\n * This uses the temporal object to find the range of valid values for the field.\n * This is similar to {@link #range()}, however this method refines the result\n * using the temporal. For example, if the field is {@code DAY_OF_MONTH} the\n * {@code range} method is not accurate as there are four possible month lengths,\n * 28, 29, 30 and 31 days. Using this method with a date allows the range to be\n * accurate, returning just one of those four options.\n *
\n * There are two equivalent ways of using this method.\n * The first is to invoke this method directly.\n * The second is to use {@link TemporalAccessor#range(TemporalField)}:\n *
\n * // these two lines are equivalent, but the second approach is recommended\n * temporal = thisField.rangeRefinedBy(temporal);\n * temporal = temporal.range(thisField);\n *\n * It is recommended to use the second approach, {@code range(TemporalField)},\n * as it is a lot clearer to read in code.\n *
\n * Implementations should perform any queries or calculations using the fields\n * available in {@link ChronoField}.\n * If the field is not supported a {@code DateTimeException} must be thrown.\n *\n * @param {TemporalAccessor} temporal the temporal object used to refine the result, not null\n * @return {Va;lueRange} the range of valid values for this field, not null\n * @throws DateTimeException if the range for the field cannot be obtained\n */\n rangeRefinedBy(temporal) {\n return temporal.range(this);\n }\n\n /**\n * Checks that the specified value is valid and fits in an {@code int}.\n *
\n * This validates that the value is within the outer range of valid values\n * returned by {@link #range()}.\n * It also checks that all valid values are within the bounds of an {@code int}.\n *
\n * This method checks against the range of the field in the ISO-8601 calendar system.\n * This range may be incorrect for other calendar systems.\n * Use {@link Chronology#range(ChronoField)} to access the correct range\n * for a different calendar system.\n *\n * @param value the value to check\n * @return the value that was passed in\n */\n checkValidIntValue(value) {\n return this.range().checkValidIntValue(value, this);\n }\n\n getFrom(temporal) {\n return temporal.getLong(this);\n }\n\n toString(){\n return this.name();\n }\n\n equals(other){\n return this === other;\n }\n}\n\nexport function _init() {\n\n ChronoField.NANO_OF_SECOND = new ChronoField('NanoOfSecond', ChronoUnit.NANOS, ChronoUnit.SECONDS, ValueRange.of(0, 999999999));\n\n ChronoField.NANO_OF_DAY = new ChronoField('NanoOfDay', ChronoUnit.NANOS, ChronoUnit.DAYS, ValueRange.of(0, 86400 * 1000000000 - 1));\n\n ChronoField.MICRO_OF_SECOND = new ChronoField('MicroOfSecond', ChronoUnit.MICROS, ChronoUnit.SECONDS, ValueRange.of(0, 999999));\n\n ChronoField.MICRO_OF_DAY = new ChronoField('MicroOfDay', ChronoUnit.MICROS, ChronoUnit.DAYS, ValueRange.of(0, 86400 * 1000000 - 1));\n\n ChronoField.MILLI_OF_SECOND = new ChronoField('MilliOfSecond', ChronoUnit.MILLIS, ChronoUnit.SECONDS, ValueRange.of(0, 999));\n\n ChronoField.MILLI_OF_DAY = new ChronoField('MilliOfDay', ChronoUnit.MILLIS, ChronoUnit.DAYS, ValueRange.of(0, 86400 * 1000 - 1));\n\n ChronoField.SECOND_OF_MINUTE = new ChronoField('SecondOfMinute', ChronoUnit.SECONDS, ChronoUnit.MINUTES, ValueRange.of(0, 59));\n\n ChronoField.SECOND_OF_DAY = new ChronoField('SecondOfDay', ChronoUnit.SECONDS, ChronoUnit.DAYS, ValueRange.of(0, 86400 - 1));\n\n ChronoField.MINUTE_OF_HOUR = new ChronoField('MinuteOfHour', ChronoUnit.MINUTES, ChronoUnit.HOURS, ValueRange.of(0, 59));\n\n ChronoField.MINUTE_OF_DAY = new ChronoField('MinuteOfDay', ChronoUnit.MINUTES, ChronoUnit.DAYS, ValueRange.of(0, (24 * 60) - 1));\n\n ChronoField.HOUR_OF_AMPM = new ChronoField('HourOfAmPm', ChronoUnit.HOURS, ChronoUnit.HALF_DAYS, ValueRange.of(0, 11));\n\n ChronoField.CLOCK_HOUR_OF_AMPM = new ChronoField('ClockHourOfAmPm', ChronoUnit.HOURS, ChronoUnit.HALF_DAYS, ValueRange.of(1, 12));\n\n ChronoField.HOUR_OF_DAY = new ChronoField('HourOfDay', ChronoUnit.HOURS, ChronoUnit.DAYS, ValueRange.of(0, 23));\n\n ChronoField.CLOCK_HOUR_OF_DAY = new ChronoField('ClockHourOfDay', ChronoUnit.HOURS, ChronoUnit.DAYS, ValueRange.of(1, 24));\n\n ChronoField.AMPM_OF_DAY = new ChronoField('AmPmOfDay', ChronoUnit.HALF_DAYS, ChronoUnit.DAYS, ValueRange.of(0, 1));\n\n ChronoField.DAY_OF_WEEK = new ChronoField('DayOfWeek', ChronoUnit.DAYS, ChronoUnit.WEEKS, ValueRange.of(1, 7));\n\n ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH = new ChronoField('AlignedDayOfWeekInMonth', ChronoUnit.DAYS, ChronoUnit.WEEKS, ValueRange.of(1, 7));\n\n ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR = new ChronoField('AlignedDayOfWeekInYear', ChronoUnit.DAYS, ChronoUnit.WEEKS, ValueRange.of(1, 7));\n\n ChronoField.DAY_OF_MONTH = new ChronoField('DayOfMonth', ChronoUnit.DAYS, ChronoUnit.MONTHS, ValueRange.of(1, 28, 31), 'day');\n\n ChronoField.DAY_OF_YEAR = new ChronoField('DayOfYear', ChronoUnit.DAYS, ChronoUnit.YEARS, ValueRange.of(1, 365, 366));\n\n ChronoField.EPOCH_DAY = new ChronoField('EpochDay', ChronoUnit.DAYS, ChronoUnit.FOREVER, ValueRange.of(Math.floor(Year.MIN_VALUE * 365.25), Math.floor(Year.MAX_VALUE * 365.25)));\n\n ChronoField.ALIGNED_WEEK_OF_MONTH = new ChronoField('AlignedWeekOfMonth', ChronoUnit.WEEKS, ChronoUnit.MONTHS, ValueRange.of(1, 4, 5));\n\n ChronoField.ALIGNED_WEEK_OF_YEAR = new ChronoField('AlignedWeekOfYear', ChronoUnit.WEEKS, ChronoUnit.YEARS, ValueRange.of(1, 53));\n\n ChronoField.MONTH_OF_YEAR = new ChronoField('MonthOfYear', ChronoUnit.MONTHS, ChronoUnit.YEARS, ValueRange.of(1, 12), 'month');\n\n ChronoField.PROLEPTIC_MONTH = new ChronoField('ProlepticMonth', ChronoUnit.MONTHS, ChronoUnit.FOREVER, ValueRange.of(Year.MIN_VALUE * 12, Year.MAX_VALUE * 12 + 11));\n\n ChronoField.YEAR_OF_ERA = new ChronoField('YearOfEra', ChronoUnit.YEARS, ChronoUnit.FOREVER, ValueRange.of(1, Year.MAX_VALUE, Year.MAX_VALUE + 1));\n\n ChronoField.YEAR = new ChronoField('Year', ChronoUnit.YEARS, ChronoUnit.FOREVER, ValueRange.of(Year.MIN_VALUE, Year.MAX_VALUE), 'year');\n\n ChronoField.ERA = new ChronoField('Era', ChronoUnit.ERAS, ChronoUnit.FOREVER, ValueRange.of(0, 1));\n\n ChronoField.INSTANT_SECONDS = new ChronoField('InstantSeconds', ChronoUnit.SECONDS, ChronoUnit.FOREVER, ValueRange.of(MIN_SAFE_INTEGER, MAX_SAFE_INTEGER));\n\n ChronoField.OFFSET_SECONDS = new ChronoField('OffsetSeconds', ChronoUnit.SECONDS, ChronoUnit.FOREVER, ValueRange.of(-18 * 3600, 18 * 3600));\n\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/temporal/ChronoField.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {ArithmeticException} from './errors';\n\nexport const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Math.pow(2, 53) - 1; // Number.MAX_SAFE_INTEGER not defined in #@#$%! PhantomJS\nexport const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER ? Number.MIN_SAFE_INTEGER : -(Math.pow(2, 53) - 1); // Number.MIN_SAFE_INTEGER not defined in #@#$%! PhantomJS\n\n/**\n * Math helper with static function for integer operations\n */\nexport class MathUtil {\n static intDiv(x, y) {\n var r = x/y;\n if(r === 0){\n return 0;\n } else if(r < 0){\n return Math.ceil(r);\n } else {\n return Math.floor(r);\n }\n }\n\n static intMod(x, y) {\n var r = x - MathUtil.intDiv(x, y) * y;\n if(r === 0){\n return 0;\n } else if(r < 0){\n return Math.ceil(r);\n } else {\n return Math.floor(r);\n }\n }\n\n static floorDiv(x, y){\n var r = Math.floor(x / y);\n return r;\n }\n\n static floorMod(x, y){\n var r = x - MathUtil.floorDiv(x, y) * y;\n return r;\n }\n \n static safeAdd(x, y) {\n if (x === 0) {\n let r = y;\n if (r > MAX_SAFE_INTEGER || r < MIN_SAFE_INTEGER) {\n throw new ArithmeticException('Invalid addition beyond MAX_SAFE_INTEGER!');\n }\n return r;\n }\n if (y === 0) {\n let r = x;\n if (r > MAX_SAFE_INTEGER || r < MIN_SAFE_INTEGER) {\n throw new ArithmeticException('Invalid addition beyond MAX_SAFE_INTEGER!');\n }\n return r;\n }\n if (x === undefined || y === undefined) {\n throw new ArithmeticException('Invalid addition using undefined as argument');\n }\n if (isNaN(x) || isNaN(y)) {\n throw new ArithmeticException('Invalid addition using NaN as argument');\n }\n let r = x + y;\n // detect overflow, since neither x nor y are 0 (checked above) r cannot be === x or === y\n // TODO: is this correct and complete?\n if (r > MAX_SAFE_INTEGER || r < MIN_SAFE_INTEGER || r === x || r === y) {\n throw new ArithmeticException('Invalid addition beyond MAX_SAFE_INTEGER!');\n }\n return r;\n }\n \n static safeSubtract(x, y) {\n if (x === 0) {\n let r = y;\n if (r > MAX_SAFE_INTEGER || r < MIN_SAFE_INTEGER) {\n throw new ArithmeticException('Invalid addition beyond MAX_SAFE_INTEGER!');\n }\n return -1 * r;\n }\n if (y === 0) {\n let r = x;\n if (r > MAX_SAFE_INTEGER || r < MIN_SAFE_INTEGER) {\n throw new ArithmeticException('Invalid addition beyond MAX_SAFE_INTEGER!');\n }\n return r;\n }\n if (x === undefined || y === undefined) {\n throw new ArithmeticException('Invalid subtraction using undefined as argument');\n }\n if (isNaN(x) || isNaN(y)) {\n throw new ArithmeticException('Invalid subtraction using NaN as argument');\n }\n let r = x - y;\n // detect overflow, since neither x nor y are 0 (checked above) r cannot be === x or === y\n // TODO: is this correct and complete?\n if (r < MIN_SAFE_INTEGER || r > MAX_SAFE_INTEGER) {\n throw new ArithmeticException('Invalid subtraction beyond MIN_SAFE_INTEGER! ' + x + '-' + y);\n }\n return r;\n }\n\n static safeMultiply(x, y) {\n if (x === 1) {\n return y;\n }\n if (y === 1) {\n return x;\n }\n if (x === 0 || y === 0) {\n return 0;\n }\n let r = x * y;\n if (r < MIN_SAFE_INTEGER || r > MAX_SAFE_INTEGER || r / y !== x || (x === MIN_SAFE_INTEGER && y === -1) || (y === MIN_SAFE_INTEGER && x === -1)) {\n throw new ArithmeticException('Multiplication overflows: ' + x + ' * ' + y);\n }\n return r;\n }\n\n static safeToInt(value) {\n if(value === 0){\n return 0;\n }\n if (isNaN(value)) {\n throw new ArithmeticException('Invalid int value, using NaN as argument');\n }\n if (value > MAX_SAFE_INTEGER || value < MIN_SAFE_INTEGER) {\n throw new ArithmeticException('Calculation overflows an int: ' + value);\n }\n return value;\n }\n\n static parseInt(value) {\n var int = parseInt(value);\n if (isNaN(int)) {\n throw new ArithmeticException('Invalid int value parse to NaN: ' + value);\n }\n if (int > MAX_SAFE_INTEGER || int < MIN_SAFE_INTEGER) {\n throw new ArithmeticException('Calculation overflows an int: ' + value);\n }\n return int;\n }\n\n /**\n * Compares two Numbers.\n *\n * @param {Number} a the first value\n * @param {Number} b the second value\n * @return {Number} the result\n */\n static compareNumbers(a, b) {\n if (a < b) {\n return -1;\n }\n if (a > b) {\n return 1;\n }\n return 0;\n }\n\n}\n\nMathUtil.MAX_SAFE_INTEGER = MAX_SAFE_INTEGER;\nMathUtil.MIN_SAFE_INTEGER = MIN_SAFE_INTEGER;\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/MathUtil.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport ExtendableError from 'es6-error';\n\nexport class DateTimeException extends ExtendableError {\n constructor(message = 'DateTimeException', cause = null) {\n let msg = message;\n if (cause !== null && cause instanceof Error) {\n msg += '\\n-------\\nCaused by: ' + cause.stack + '\\n-------\\n';\n }\n super(msg);\n }\n}\n\nexport class DateTimeParseException extends ExtendableError {\n constructor(message = 'DateTimeParseException', text = '', index = 0, cause = null) {\n let msg = message + ': ' + text + ', at index: ' + index;\n if (cause !== null && cause instanceof Error) {\n msg += '\\n-------\\nCaused by: ' + cause.stack + '\\n-------\\n';\n }\n super(msg);\n }\n}\n\nexport class UnsupportedTemporalTypeException extends DateTimeException {\n constructor(message = 'UnsupportedTemporalTypeException') {\n super(message);\n }\n}\n\nexport class ArithmeticException extends ExtendableError {\n constructor(message = 'ArithmeticException') {\n super(message);\n }\n}\n\nexport class IllegalArgumentException extends ExtendableError {\n constructor(message = 'IllegalArgumentException') {\n super(message);\n }\n}\n\nexport class NullPointerException extends ExtendableError {\n constructor(message = 'NullPointerException') {\n super(message);\n }\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/errors.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nvar _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar ExtendableError = (function (_Error) {\n _inherits(ExtendableError, _Error);\n\n function ExtendableError() {\n var message = arguments.length <= 0 || arguments[0] === undefined ? '' : arguments[0];\n\n _classCallCheck(this, ExtendableError);\n\n _get(Object.getPrototypeOf(ExtendableError.prototype), 'constructor', this).call(this, message);\n\n // extending Error is weird and does not propagate `message`\n Object.defineProperty(this, 'message', {\n enumerable: false,\n value: message\n });\n\n Object.defineProperty(this, 'name', {\n enumerable: false,\n value: this.constructor.name\n });\n\n if (Error.hasOwnProperty('captureStackTrace')) {\n Error.captureStackTrace(this, this.constructor);\n return;\n }\n\n Object.defineProperty(this, 'stack', {\n enumerable: false,\n value: new Error(message).stack\n });\n }\n\n return ExtendableError;\n})(Error);\n\nexports['default'] = ExtendableError;\nmodule.exports = exports['default'];\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/es6-error/dist/index.js\n ** module id = 6\n ** module chunks = 0\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {Duration} from '../Duration';\nimport {Year} from '../Year';\n\n/**\n * A standard set of date periods units.\n *
\n * This set of units provide unit-based access to manipulate a date, time or date-time.\n * The standard set of units can be extended by implementing {@link TemporalUnit}.\n *
\n * These units are intended to be applicable in multiple calendar systems.\n * For example, most non-ISO calendar systems define units of years, months and days,\n * just with slightly different rules.\n * The documentation of each unit explains how it operates.\n *\n */\nexport class ChronoUnit /*implements TemporalUnit*/ {\n\n /**\n * \n * @param {String} name\n * @param {Duration} estimatedDuration\n */\n constructor (name, estimatedDuration) {\n this._name = name;\n this._duration = estimatedDuration;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Gets the estimated duration of this unit in the ISO calendar system.\n *
\n * All of the units in this class have an estimated duration.\n * Days vary due to daylight saving time, while months have different lengths.\n *\n * @return {Duration} the estimated duration of this unit, not null\n */\n duration() {\n return this._duration;\n }\n\n /**\n * Checks if the duration of the unit is an estimate.\n *
\n * All time units in this class are considered to be accurate, while all date\n * units in this class are considered to be estimated.\n *
\n * This definition ignores leap seconds, but considers that Days vary due to\n * daylight saving time and months have different lengths.\n *\n * @return {boolean} true if the duration is estimated, false if accurate\n */\n isDurationEstimated() {\n return this.isDateBased() || this === ChronoUnit.FOREVER;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Checks if this unit is a date unit.\n *\n * @return true if a date unit, false if a time unit\n */\n isDateBased() {\n return this.compareTo(ChronoUnit.DAYS) >= 0 && this !== ChronoUnit.FOREVER;\n }\n\n /**\n * Checks if this unit is a time unit.\n *\n * @return true if a time unit, false if a date unit\n */\n isTimeBased() {\n return this.compareTo(ChronoUnit.DAYS) < 0;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Checks if this unit is supported by the specified temporal object.\n *
\n * This checks that the implementing date-time can add/subtract this unit.\n * This can be used to avoid throwing an exception.\n *
\n * This default implementation derives the value using\n * {@link Temporal#plus(long, TemporalUnit)}.\n *\n * @param {Temporal} temporal the temporal object to check, not null\n * @return {boolean} true if the unit is supported\n */\n isSupportedBy(temporal) {\n if (this === ChronoUnit.FOREVER) {\n return false;\n }\n /* TODO: classes not implemented yet */\n/*\n if (temporal instanceof ChronoLocalDate) {\n return isDateBased();\n }\n if (temporal instanceof ChronoLocalDateTime || temporal instanceof ChronoZonedDateTime) {\n return true;\n }\n*/\n try {\n temporal.plus(1, this);\n return true;\n } catch (e) {\n try {\n temporal.plus(-1, this);\n return true;\n } catch (e2) {\n return false;\n }\n }\n }\n\n /**\n * Returns a copy of the specified temporal object with the specified period added.\n *
\n * The period added is a multiple of this unit. For example, this method\n * could be used to add \"3 days\" to a date by calling this method on the\n * instance representing \"days\", passing the date and the period \"3\".\n * The period to be added may be negative, which is equivalent to subtraction.\n *
\n * There are two equivalent ways of using this method.\n * The first is to invoke this method directly.\n * The second is to use {@link Temporal#plus(long, TemporalUnit)}:\n *
\n * // these two lines are equivalent, but the second approach is recommended\n * temporal = thisUnit.addTo(temporal);\n * temporal = temporal.plus(thisUnit);\n *\n * It is recommended to use the second approach, {@code plus(TemporalUnit)},\n * as it is a lot clearer to read in code.\n *
\n * Implementations should perform any queries or calculations using the units\n * available in {@link ChronoUnit} or the fields available in {@link ChronoField}.\n * If the unit is not supported an {@code UnsupportedTemporalTypeException} must be thrown.\n *
\n * Implementations must not alter the specified temporal object.\n * Instead, an adjusted copy of the original must be returned.\n * This provides equivalent, safe behavior for immutable and mutable implementations.\n *\n * @param {Temporal} temporal the temporal object to adjust, not null\n * @param {Number} amount the amount of this unit to add, positive or negative\n * @return {Temporal} the adjusted temporal object, not null\n * @throws DateTimeException if the amount cannot be added\n * @throws UnsupportedTemporalTypeException if the unit is not supported by the temporal\n */\n addTo(temporal, amount) {\n return temporal.plus(amount, this);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Calculates the amount of time between two temporal objects.\n *
\n * This calculates the amount in terms of this unit. The start and end\n * points are supplied as temporal objects and must be of compatible types.\n * The implementation will convert the second type to be an instance of the\n * first type before the calculating the amount.\n * The result will be negative if the end is before the start.\n * For example, the amount in hours between two temporal objects can be\n * calculated using {@code HOURS.between(startTime, endTime)}.\n *
\n * The calculation returns a whole number, representing the number of\n * complete units between the two temporals.\n * For example, the amount in hours between the times 11:30 and 13:29\n * will only be one hour as it is one minute short of two hours.\n *
\n * There are two equivalent ways of using this method.\n * The first is to invoke this method directly.\n * The second is to use {@link Temporal#until(Temporal, TemporalUnit)}:\n *
\n * // these two lines are equivalent\n * between = thisUnit.between(start, end);\n * between = start.until(end, thisUnit);\n *\n * The choice should be made based on which makes the code more readable.\n *
\n * For example, this method allows the number of days between two dates to\n * be calculated:\n *
\n * daysBetween = DAYS.between(start, end);\n * // or alternatively\n * daysBetween = start.until(end, DAYS);\n *\n *
\n * Implementations should perform any queries or calculations using the units\n * available in {@link ChronoUnit} or the fields available in {@link ChronoField}.\n * If the unit is not supported an {@code UnsupportedTemporalTypeException} must be thrown.\n * Implementations must not alter the specified temporal objects.\n *\n * @implSpec\n * Implementations must begin by checking to if the two temporals have the\n * same type using {@code .constructor.name}. If they do not, then the result must be\n * obtained by calling {@code temporal1.until(temporal2, this)}.\n *\n * @param {Temporal} temporal1 the base temporal object, not null\n * @param {Temporal} temporal2 the other temporal object, exclusive, not null\n * @return {Number} the amount of time between temporal1 and temporal2\n * in terms of this unit; positive if temporal2 is later than\n * temporal1, negative if earlier\n * @throws DateTimeException if the amount cannot be calculated, or the end\n * temporal cannot be converted to the same type as the start temporal\n * @throws UnsupportedTemporalTypeException if the unit is not supported by the temporal\n * @throws ArithmeticException if numeric overflow occurs\n */\n between(temporal1, temporal2) {\n return temporal1.until(temporal2, this);\n }\n\n //-----------------------------------------------------------------------\n toString() {\n return this._name;\n }\n\n /**\n * Compares this ChronoUnit to the specified {TemporalUnit}.\n *
\n * The comparison is based on the total length of the durations.\n *\n * @param {TemporalUnit} other the other unit to compare to, not null\n * @return the comparator value, negative if less, positive if greater\n */\n compareTo(other) {\n return this.duration().compareTo(other.duration());\n }\n\n}\n\nexport function _init() {\n /**\n * Unit that represents the concept of a nanosecond, the smallest supported unit of time.\n * For the ISO calendar system, it is equal to the 1,000,000,000th part of the second unit.\n */\n ChronoUnit.NANOS = new ChronoUnit('Nanos', Duration.ofNanos(1));\n /**\n * Unit that represents the concept of a microsecond.\n * For the ISO calendar system, it is equal to the 1,000,000th part of the second unit.\n */\n ChronoUnit.MICROS = new ChronoUnit('Micros', Duration.ofNanos(1000));\n /**\n * Unit that represents the concept of a millisecond.\n * For the ISO calendar system, it is equal to the 1000th part of the second unit.\n */\n ChronoUnit.MILLIS = new ChronoUnit('Millis', Duration.ofNanos(1000000));\n /**\n * Unit that represents the concept of a second.\n * For the ISO calendar system, it is equal to the second in the SI system\n * of units, except around a leap-second.\n */\n ChronoUnit.SECONDS = new ChronoUnit('Seconds', Duration.ofSeconds(1));\n /**\n * Unit that represents the concept of a minute.\n * For the ISO calendar system, it is equal to 60 seconds.\n */\n ChronoUnit.MINUTES = new ChronoUnit('Minutes', Duration.ofSeconds(60));\n /**\n * Unit that represents the concept of an hour.\n * For the ISO calendar system, it is equal to 60 minutes.\n */\n ChronoUnit.HOURS = new ChronoUnit('Hours', Duration.ofSeconds(3600));\n /**\n * Unit that represents the concept of half a day, as used in AM/PM.\n * For the ISO calendar system, it is equal to 12 hours.\n */\n ChronoUnit.HALF_DAYS = new ChronoUnit('HalfDays', Duration.ofSeconds(43200));\n /**\n * Unit that represents the concept of a day.\n * For the ISO calendar system, it is the standard day from midnight to midnight.\n * The estimated duration of a day is {@code 24 Hours}.\n *
\n * When used with other calendar systems it must correspond to the day defined by\n * the rising and setting of the Sun on Earth. It is not required that days begin\n * at midnight - when converting between calendar systems, the date should be\n * equivalent at midday.\n */\n ChronoUnit.DAYS = new ChronoUnit('Days', Duration.ofSeconds(86400));\n /**\n * Unit that represents the concept of a week.\n * For the ISO calendar system, it is equal to 7 days.\n *
\n * When used with other calendar systems it must correspond to an integral number of days.\n */\n ChronoUnit.WEEKS = new ChronoUnit('Weeks', Duration.ofSeconds(7 * 86400));\n /**\n * Unit that represents the concept of a month.\n * For the ISO calendar system, the length of the month varies by month-of-year.\n * The estimated duration of a month is one twelfth of {@code 365.2425 Days}.\n *
\n * When used with other calendar systems it must correspond to an integral number of days.\n */\n ChronoUnit.MONTHS = new ChronoUnit('Months', Duration.ofSeconds(31556952 / 12));\n /**\n * Unit that represents the concept of a year.\n * For the ISO calendar system, it is equal to 12 months.\n * The estimated duration of a year is {@code 365.2425 Days}.\n *
\n * When used with other calendar systems it must correspond to an integral number of days\n * or months roughly equal to a year defined by the passage of the Earth around the Sun.\n */\n ChronoUnit.YEARS = new ChronoUnit('Years', Duration.ofSeconds(31556952));\n /**\n * Unit that represents the concept of a decade.\n * For the ISO calendar system, it is equal to 10 years.\n *
\n * When used with other calendar systems it must correspond to an integral number of days\n * and is normally an integral number of years.\n */\n ChronoUnit.DECADES = new ChronoUnit('Decades', Duration.ofSeconds(31556952 * 10));\n /**\n * Unit that represents the concept of a century.\n * For the ISO calendar system, it is equal to 100 years.\n *
\n * When used with other calendar systems it must correspond to an integral number of days\n * and is normally an integral number of years.\n */\n ChronoUnit.CENTURIES = new ChronoUnit('Centuries', Duration.ofSeconds(31556952 * 100));\n /**\n * Unit that represents the concept of a millennium.\n * For the ISO calendar system, it is equal to 1000 years.\n *
\n * When used with other calendar systems it must correspond to an integral number of days\n * and is normally an integral number of years.\n */\n ChronoUnit.MILLENNIA = new ChronoUnit('Millennia', Duration.ofSeconds(31556952 * 1000));\n /**\n * Unit that represents the concept of an era.\n * The ISO calendar system doesn't have eras thus it is impossible to add\n * an era to a date or date-time.\n * The estimated duration of the era is artificially defined as {Year.MAX_VALUE} + 1.\n *
\n * When used with other calendar systems there are no restrictions on the unit.\n */\n ChronoUnit.ERAS = new ChronoUnit('Eras', Duration.ofSeconds(31556952 * (Year.MAX_VALUE + 1)));\n /**\n * Artificial unit that represents the concept of forever.\n * This is primarily used with {@link TemporalField} to represent unbounded fields\n * such as the year or era.\n * The estimated duration of the era is artificially defined as the largest duration\n * supported by {@code Duration}.\n */\n ChronoUnit.FOREVER = new ChronoUnit('Forever', Duration.ofSeconds(Number.MAX_SAFE_INTEGER, 999999999));\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/temporal/ChronoUnit.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {requireNonNull, requireInstance} from './assert';\nimport {ArithmeticException, DateTimeParseException, UnsupportedTemporalTypeException} from './errors';\nimport {MathUtil, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER} from './MathUtil';\n\nimport {ChronoField} from './temporal/ChronoField';\nimport {ChronoUnit} from './temporal/ChronoUnit';\nimport {TemporalAmount} from './temporal/TemporalAmount';\n\nimport {LocalTime} from './LocalTime';\n\n/**\n * A time-based amount of time, such as '34.5 seconds'.\n *
\n * This class models a quantity or amount of time in terms of seconds and nanoseconds.\n * It can be accessed using other duration-based units, such as minutes and hours.\n * In addition, the {@link ChronoUnit#DAYS DAYS} unit can be used and is treated as\n * exactly equal to 24 hours, thus ignoring daylight savings effects.\n * See {@link Period} for the date-based equivalent to this class.\n *
\n * A physical duration could be of infinite length.\n * For practicality, the duration is stored with constraints similar to {@link Instant}.\n * The duration uses nanosecond resolution with a maximum value of the seconds that can\n * be held in a {@code long}. This is greater than the current estimated age of the universe.\n *
\n * The range of a duration requires the storage of a number larger than a {@code long}.\n * To achieve this, the class stores a {@code long} representing seconds and an {@code int}\n * representing nanosecond-of-second, which will always be between 0 and 999,999,999.\n *
\n * The duration is measured in \"seconds\", but these are not necessarily identical to\n * the scientific \"SI second\" definition based on atomic clocks.\n * This difference only impacts durations measured near a leap-second and should not affect\n * most applications.\n * See {@link Instant} for a discussion as to the meaning of the second and time-scales.\n *\n */\nexport class Duration extends TemporalAmount\n /*implements TemporalAmount, Comparable \n * The seconds are calculated based on the standard definition of a day,\n * where each day is 86400 seconds which implies a 24 hour day.\n * The nanosecond in second field is set to zero.\n *\n * @param {Number} days the number of days, positive or negative\n * @return {@code Duration}, not null\n * @throws ArithmeticException if the input days exceeds the capacity of {@code Duration}\n */\n static ofDays(days) {\n return Duration.create(MathUtil.safeMultiply(days, LocalTime.SECONDS_PER_DAY), 0);\n }\n\n /**\n * Obtains an instance of {@code Duration} from a number of standard hours.\n * \n * The seconds are calculated based on the standard definition of an hour,\n * where each hour is 3600 seconds.\n * The nanosecond in second field is set to zero.\n *\n * @param {Number} hours the number of hours, positive or negative\n * @return {@code Duration}, not null\n * @throws ArithmeticException if the input hours exceeds the capacity of {@code Duration}\n */\n static ofHours(hours) {\n return Duration.create(MathUtil.safeMultiply(hours, LocalTime.SECONDS_PER_HOUR), 0);\n }\n\n /**\n * Obtains an instance of {@code Duration} from a number of standard minutes.\n * \n * The seconds are calculated based on the standard definition of a minute,\n * where each minute is 60 seconds.\n * The nanosecond in second field is set to zero.\n *\n * @param {Number} minutes the number of minutes, positive or negative\n * @return {@code Duration}, not null\n * @throws ArithmeticException if the input minutes exceeds the capacity of {@code Duration}\n */\n static ofMinutes(minutes) {\n return Duration.create(MathUtil.safeMultiply(minutes, LocalTime.SECONDS_PER_MINUTE), 0);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains an instance of {@code Duration} from a number of seconds\n * and an adjustment in nanoseconds.\n * \n * This method allows an arbitrary number of nanoseconds to be passed in.\n * The factory will alter the values of the second and nanosecond in order\n * to ensure that the stored nanosecond is in the range 0 to 999,999,999.\n * For example, the following will result in the exactly the same duration:\n * \n * The seconds and nanoseconds are extracted from the specified milliseconds.\n *\n * @param {Number} millis the number of milliseconds, positive or negative\n * @return {@code Duration}, not null\n */\n static ofMillis(millis) {\n var secs = MathUtil.intDiv(millis, 1000);\n var mos = MathUtil.intMod(millis, 1000);\n if (mos < 0) {\n mos += 1000;\n secs--;\n }\n return Duration.create(secs, mos * 1000000);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains an instance of {@code Duration} from a number of nanoseconds.\n * \n * The seconds and nanoseconds are extracted from the specified nanoseconds.\n *\n * @param {Number} nanos the number of nanoseconds, positive or negative\n * @return {@code Duration}, not null\n */\n static ofNanos(nanos) {\n var secs = MathUtil.intDiv(nanos, LocalTime.NANOS_PER_SECOND);\n var nos = MathUtil.intMod(nanos, LocalTime.NANOS_PER_SECOND);\n if (nos < 0) {\n nos += LocalTime.NANOS_PER_SECOND;\n secs--;\n }\n return this.create(secs, nos);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains an instance of {@code Duration} from a duration in the specified unit.\n * \n * The parameters represent the two parts of a phrase like '6 Hours'. For example:\n * \n * This obtains a duration based on the specified amount.\n * A TemporalAmount represents an amount of time, which may be date-based\n * or time-based, which this factory extracts to a duration.\n * \n * The conversion loops around the set of units from the amount and uses\n * the duration of the unit to calculate the total Duration.\n * Only a subset of units are accepted by this method.\n * The unit must either have an exact duration or be ChronoUnit.DAYS which\n * is treated as 24 hours. If any other units are found then an exception is thrown.\n *\n * @param {Number} amount the temporal amount to convert, not null\n * @return {Duration} the resulting duration, not null\n * @throws DateTimeException if the amount cannot be converted\n * @throws ArithmeticException if a numeric overflow occurs\n */\n static from(amount) {\n requireNonNull(amount, 'amount');\n var duration = Duration.ZERO;\n amount.units().forEach((unit) => {\n duration = duration.plus(amount.get(unit), unit);\n });\n return duration;\n }\n \n /**\n * Obtains an instance of {@code Duration} representing the duration between two instants.\n * \n * Obtains a {@code Duration} representing the duration between two instants.\n * This calculates the duration between two temporal objects of the same type.\n * The difference in seconds is calculated using {@link Temporal#until(Temporal, TemporalUnit)}.\n * The difference in nanoseconds is calculated using by querying the\n * {@link ChronoField#NANO_OF_SECOND NANO_OF_SECOND} field.\n * \n * The result of this method can be a negative period if the end is before the start.\n * To guarantee to obtain a positive duration call abs() on the result.\n *\n * @param {Temporal} startInclusive the start instant, inclusive, not null\n * @param {Temporal} endExclusive the end instant, exclusive, not null\n * @return {@code Duration}, not null\n * @throws DateTimeException if the seconds between the temporals cannot be obtained\n * @throws ArithmeticException if the calculation exceeds the capacity of {@code Duration}\n */\n static between(startInclusive, endExclusive) {\n requireNonNull(startInclusive, 'startInclusive');\n requireNonNull(endExclusive, 'endExclusive');\n var secs = startInclusive.until(endExclusive, ChronoUnit.SECONDS);\n var nanos = 0;\n if (startInclusive.isSupported(ChronoField.NANO_OF_SECOND) && endExclusive.isSupported(ChronoField.NANO_OF_SECOND)) {\n try {\n let startNos = startInclusive.getLong(ChronoField.NANO_OF_SECOND);\n nanos = endExclusive.getLong(ChronoField.NANO_OF_SECOND) - startNos;\n if (secs > 0 && nanos < 0) {\n nanos += LocalTime.NANOS_PER_SECOND;\n } else if (secs < 0 && nanos > 0) {\n nanos -= LocalTime.NANOS_PER_SECOND;\n } else if (secs === 0 && nanos !== 0) {\n // two possible meanings for result, so recalculate secs\n let adjustedEnd = endExclusive.with(ChronoField.NANO_OF_SECOND, startNos);\n secs = startInclusive.until(adjustedEnd, ChronoUnit.SECONDS);\n }\n } catch (e) {\n // ignore and only use seconds\n }\n }\n return this.ofSeconds(secs, nanos);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains a {@code Duration} from a text string such as {@code PnDTnHnMn.nS}.\n * \n * This will parse a textual representation of a duration, including the\n * string produced by {@code toString()}. The formats accepted are based\n * on the ISO-8601 duration format {@code PnDTnHnMn.nS} with days\n * considered to be exactly 24 hours.\n * \n * The string starts with an optional sign, denoted by the ASCII negative\n * or positive symbol. If negative, the whole period is negated.\n * The ASCII letter \"P\" is next in upper or lower case.\n * There are then four sections, each consisting of a number and a suffix.\n * The sections have suffixes in ASCII of \"D\", \"H\", \"M\" and \"S\" for\n * days, hours, minutes and seconds, accepted in upper or lower case.\n * The suffixes must occur in order. The ASCII letter \"T\" must occur before\n * the first occurrence, if any, of an hour, minute or second section.\n * At least one of the four sections must be present, and if \"T\" is present\n * there must be at least one section after the \"T\".\n * The number part of each section must consist of one or more ASCII digits.\n * The number may be prefixed by the ASCII negative or positive symbol.\n * The number of days, hours and minutes must parse to a {@code long}.\n * The number of seconds must parse to a {@code long} with optional fraction.\n * The decimal point may be either a dot or a comma.\n * The fractional part may have from zero to 9 digits.\n * \n * The leading plus/minus sign, and negative values for other units are\n * not part of the ISO-8601 standard.\n * \n * Examples:\n * \n * This returns a value for each of the two supported units,\n * {@link ChronoUnit#SECONDS SECONDS} and {@link ChronoUnit#NANOS NANOS}.\n * All other units throw an exception.\n *\n * @param {TemporalUnit} unit the {@code TemporalUnit} for which to return the value\n * @return {Number} the var value of the unit\n * @throws DateTimeException if the unit is not supported\n * @throws UnsupportedTemporalTypeException if the unit is not supported\n */\n get(unit) {\n if (unit === ChronoUnit.SECONDS) {\n return this._seconds;\n } else if (unit === ChronoUnit.NANOS) {\n return this._nanos;\n } else {\n throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);\n }\n }\n\n units() {\n return [ChronoUnit.SECONDS, ChronoUnit.NANOS];\n }\n\n //-----------------------------------------------------------------------\n /**\n * Checks if this duration is zero length.\n * \n * A {@code Duration} represents a directed distance between two points on\n * the time-line and can therefore be positive, zero or negative.\n * This method checks whether the length is zero.\n *\n * @return {boolean} true if this duration has a total length equal to zero\n */\n isZero() {\n return (this._seconds | this._nanos) === 0;\n }\n\n /**\n * Checks if this duration is negative, excluding zero.\n * \n * A {@code Duration} represents a directed distance between two points on\n * the time-line and can therefore be positive, zero or negative.\n * This method checks whether the length is less than zero.\n *\n * @return {boolean} true if this duration has a total length less than zero\n */\n isNegative() {\n return this._seconds < 0;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Gets the number of seconds in this duration.\n * \n * The length of the duration is stored using two fields - seconds and nanoseconds.\n * The nanoseconds part is a value from 0 to 999,999,999 that is an adjustment to\n * the length in seconds.\n * The total duration is defined by calling this method and {@link #getNano()}.\n * \n * A {@code Duration} represents a directed distance between two points on the time-line.\n * A negative duration is expressed by the negative sign of the seconds part.\n * A duration of -1 nanosecond is stored as -1 seconds plus 999,999,999 nanoseconds.\n *\n * @return {Number} the whole seconds part of the length of the duration, positive or negative\n */\n seconds() {\n return this._seconds;\n }\n\n /**\n * Gets the number of nanoseconds within the second in this duration.\n * \n * The length of the duration is stored using two fields - seconds and nanoseconds.\n * The nanoseconds part is a value from 0 to 999,999,999 that is an adjustment to\n * the length in seconds.\n * The total duration is defined by calling this method and {@link #getSeconds()}.\n * \n * A {@code Duration} represents a directed distance between two points on the time-line.\n * A negative duration is expressed by the negative sign of the seconds part.\n * A duration of -1 nanosecond is stored as -1 seconds plus 999,999,999 nanoseconds.\n *\n * @return {Number} the nanoseconds within the second part of the length of the duration, from 0 to 999,999,999\n */\n nano() {\n return this._nanos;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this duration with the specified amount of seconds.\n * \n * This returns a duration with the specified seconds, retaining the\n * nano-of-second part of this duration.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} seconds the seconds to represent, may be negative\n * @return {@code Duration} based on this period with the requested seconds, not null\n */\n withSeconds(seconds) {\n return Duration.create(seconds, this._nanos);\n }\n\n /**\n * Returns a copy of this duration with the specified nano-of-second.\n * \n * This returns a duration with the specified nano-of-second, retaining the\n * seconds part of this duration.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} nanoOfSecond the nano-of-second to represent, from 0 to 999,999,999\n * @return {@code Duration} based on this period with the requested nano-of-second, not null\n * @throws DateTimeException if the nano-of-second is invalid\n */\n withNanos(nanoOfSecond) {\n ChronoField.NANO_OF_SECOND.checkValidIntValue(nanoOfSecond);\n return Duration.create(this._seconds, nanoOfSecond);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this duration with the specified duration added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Duration} duration the duration to add, positive or negative, not null\n * @return {@code Duration} based on this duration with the specified duration added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusDuration(duration) {\n return this.plus(duration.seconds(), duration.nano());\n }\n\n\n /**\n * to handle function overriding this function accepts two arguments, checks their type and delegates to the appropriate function\n * \n * @param a\n * @param b\n */\n plus(a, b){\n if (a instanceof Duration) {\n requireNonNull(a, 'duration');\n return this.plusDuration(a);\n }\n if (b instanceof ChronoUnit) {\n requireNonNull(a, 'amount');\n requireNonNull(b, 'unit');\n return this.plusAmountUnit(a, b);\n }\n requireNonNull(a, 'seconds');\n requireNonNull(b, 'nanos');\n return this.plusSecondsNanos(a, b);\n }\n \n /**\n * Returns a copy of this duration with the specified duration added.\n * \n * The duration amount is measured in terms of the specified unit.\n * Only a subset of units are accepted by this method.\n * The unit must either have an {@link TemporalUnit#isDurationEstimated() exact duration} or\n * be {@link ChronoUnit#DAYS} which is treated as 24 hours. Other units throw an exception.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} amountToAdd the amount to add, measured in terms of the unit, positive or negative\n * @param {TemporalUnit} unit the unit that the amount is measured in, must have an exact duration, not null\n * @return {@code Duration} based on this duration with the specified duration added, not null\n * @throws UnsupportedTemporalTypeException if the unit is not supported\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusAmountUnit(amountToAdd, unit) {\n requireNonNull(unit, 'unit');\n if (unit === ChronoUnit.DAYS) {\n return this.plusSecondsNanos(MathUtil.safeMultiply(amountToAdd, LocalTime.SECONDS_PER_DAY), 0);\n }\n if (unit.isDurationEstimated()) {\n throw new UnsupportedTemporalTypeException('Unit must not have an estimated duration');\n }\n if (amountToAdd === 0) {\n return this;\n }\n if (unit instanceof ChronoUnit) {\n switch (unit) {\n case ChronoUnit.NANOS: return this.plusNanos(amountToAdd);\n case ChronoUnit.MICROS: return this.plusSecondsNanos(MathUtil.intDiv(amountToAdd, (1000000 * 1000)) * 1000, MathUtil.intMod(amountToAdd, (1000000 * 1000)) * 1000);\n case ChronoUnit.MILLIS: return this.plusMillis(amountToAdd);\n case ChronoUnit.SECONDS: return this.plusSeconds(amountToAdd);\n }\n return this.plusSecondsNanos(MathUtil.safeMultiply(unit.duration().seconds(), amountToAdd), 0);\n }\n var duration = unit.duration().multipliedBy(amountToAdd);\n return this.plusSecondsNanos(duration.seconds(), duration.nano());\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this duration with the specified duration in 24 hour days added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} daysToAdd the days to add, positive or negative\n * @return {@code Duration} based on this duration with the specified days added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusDays(daysToAdd) {\n return this.plusSecondsNanos(MathUtil.safeMultiply(daysToAdd, LocalTime.SECONDS_PER_DAY), 0);\n }\n\n /**\n * Returns a copy of this duration with the specified duration in hours added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} hoursToAdd the hours to add, positive or negative\n * @return {@code Duration} based on this duration with the specified hours added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusHours(hoursToAdd) {\n return this.plusSecondsNanos(MathUtil.safeMultiply(hoursToAdd, LocalTime.SECONDS_PER_HOUR), 0);\n }\n\n /**\n * Returns a copy of this duration with the specified duration in minutes added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} minutesToAdd the minutes to add, positive or negative\n * @return {@code Duration} based on this duration with the specified minutes added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusMinutes(minutesToAdd) {\n return this.plusSecondsNanos(MathUtil.safeMultiply(minutesToAdd, LocalTime.SECONDS_PER_MINUTE), 0);\n }\n\n /**\n * Returns a copy of this duration with the specified duration in seconds added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} secondsToAdd the seconds to add, positive or negative\n * @return {@code Duration} based on this duration with the specified seconds added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusSeconds(secondsToAdd) {\n return this.plusSecondsNanos(secondsToAdd, 0);\n }\n\n /**\n * Returns a copy of this duration with the specified duration in milliseconds added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} millisToAdd the milliseconds to add, positive or negative\n * @return {@code Duration} based on this duration with the specified milliseconds added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusMillis(millisToAdd) {\n return this.plusSecondsNanos(MathUtil.intDiv(millisToAdd, 1000), MathUtil.intMod(millisToAdd, 1000) * 1000000);\n }\n\n /**\n * Returns a copy of this duration with the specified duration in nanoseconds added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} nanosToAdd the nanoseconds to add, positive or negative\n * @return {@code Duration} based on this duration with the specified nanoseconds added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusNanos(nanosToAdd) {\n return this.plusSecondsNanos(0, nanosToAdd);\n }\n\n /**\n * Returns a copy of this duration with the specified duration added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} secondsToAdd the seconds to add, positive or negative\n * @param {Number} nanosToAdd the nanos to add, positive or negative\n * @return {@code Duration} based on this duration with the specified seconds added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusSecondsNanos(secondsToAdd, nanosToAdd) {\n if ((secondsToAdd | nanosToAdd) === 0) {\n return this;\n }\n var epochSec = MathUtil.safeAdd(this._seconds, secondsToAdd);\n epochSec = MathUtil.safeAdd(epochSec, MathUtil.intDiv(nanosToAdd, LocalTime.NANOS_PER_SECOND));\n nanosToAdd = MathUtil.intMod(nanosToAdd, LocalTime.NANOS_PER_SECOND);\n var nanoAdjustment = MathUtil.safeAdd(this._nanos, nanosToAdd); // safe int+LocalTime.NANOS_PER_SECOND\n return Duration.ofSeconds(epochSec, nanoAdjustment);\n }\n\n //-----------------------------------------------------------------------\n /**\n * to handle function overriding this function accepts two arguments, checks their type and delegates to the appropriate function\n *\n * @param a\n * @param b\n */\n minus(a, b) {\n if (a instanceof Duration) {\n requireNonNull(a, 'duration');\n return this.minusDuration(a);\n }\n if (b instanceof ChronoUnit) {\n requireNonNull(a, 'amount');\n requireNonNull(b, 'unit');\n return this.minusAmountUnit(a, b);\n }\n requireNonNull(a, 'seconds');\n requireNonNull(b, 'nanos');\n return this.minusSecondsNanos(a, b);\n }\n\n /**\n * Returns a copy of this duration with the specified duration subtracted.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Duration} duration the duration to subtract, positive or negative, not null\n * @return {@code Duration} based on this duration with the specified duration subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusDuration(duration) {\n var secsToSubtract = duration.seconds();\n var nanosToSubtract = duration.nano();\n if (secsToSubtract === MIN_SAFE_INTEGER) {\n return this.plus(MAX_SAFE_INTEGER, -nanosToSubtract).plus(1, 0);\n }\n return this.plus(-secsToSubtract, -nanosToSubtract);\n }\n\n /**\n * Returns a copy of this duration with the specified duration subtracted.\n * \n * The duration amount is measured in terms of the specified unit.\n * Only a subset of units are accepted by this method.\n * The unit must either have an {@link TemporalUnit#isDurationEstimated() exact duration} or\n * be {@link ChronoUnit#DAYS} which is treated as 24 hours. Other units throw an exception.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} amountToSubtract the amount to subtract, measured in terms of the unit, positive or negative\n * @param {TemporalUnit} unit the unit that the amount is measured in, must have an exact duration, not null\n * @return {@code Duration} based on this duration with the specified duration subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusAmountUnit(amountToSubtract, unit) {\n return (amountToSubtract === MIN_SAFE_INTEGER ? this.plusAmountUnit(MAX_SAFE_INTEGER, unit).plus(1, unit) : this.plusAmountUnit(-amountToSubtract, unit));\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this duration with the specified duration in 24 hour days subtracted.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} daysToSubtract the days to subtract, positive or negative\n * @return {@code Duration} based on this duration with the specified days subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusDays(daysToSubtract) {\n return (daysToSubtract === MIN_SAFE_INTEGER ? this.plusDays(MAX_SAFE_INTEGER).plusDays(1) : this.plusDays(-daysToSubtract));\n }\n\n /**\n * Returns a copy of this duration with the specified duration in hours subtracted.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} hoursToSubtract the hours to subtract, positive or negative\n * @return {@code Duration} based on this duration with the specified hours subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusHours(hoursToSubtract) {\n return (hoursToSubtract === MIN_SAFE_INTEGER ? this.plusHours(MAX_SAFE_INTEGER).plusHours(1) : this.plusHours(-hoursToSubtract));\n }\n\n /**\n * Returns a copy of this duration with the specified duration in minutes subtracted.\n * \n * The number of hours is multiplied by 60 to obtain the number of seconds to subtract.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} minutesToSubtract the minutes to subtract, positive or negative\n * @return {@code Duration} based on this duration with the specified minutes subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusMinutes(minutesToSubtract) {\n return (minutesToSubtract === MIN_SAFE_INTEGER ? this.plusMinutes(MAX_SAFE_INTEGER).plusMinutes(1) : this.plusMinutes(-minutesToSubtract));\n }\n\n /**\n * Returns a copy of this duration with the specified duration in seconds subtracted.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} secondsToSubtract the seconds to subtract, positive or negative\n * @return {@code Duration} based on this duration with the specified seconds subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusSeconds(secondsToSubtract) {\n return (secondsToSubtract === MIN_SAFE_INTEGER ? this.plusSeconds(MAX_SAFE_INTEGER).plusSeconds(1) : this.plusSeconds(-secondsToSubtract));\n }\n\n /**\n * Returns a copy of this duration with the specified duration in milliseconds subtracted.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} millisToSubtract the milliseconds to subtract, positive or negative\n * @return {@code Duration} based on this duration with the specified milliseconds subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusMillis(millisToSubtract) {\n return (millisToSubtract === MIN_SAFE_INTEGER ? this.plusMillis(MAX_SAFE_INTEGER).plusMillis(1) : this.plusMillis(-millisToSubtract));\n }\n\n /**\n * Returns a copy of this duration with the specified duration in nanoseconds subtracted.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} nanosToSubtract the nanoseconds to subtract, positive or negative\n * @return {@code Duration} based on this duration with the specified nanoseconds subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusNanos(nanosToSubtract) {\n return (nanosToSubtract === MIN_SAFE_INTEGER ? this.plusNanos(MAX_SAFE_INTEGER).plusNanos(1) : this.plusNanos(-nanosToSubtract));\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this duration multiplied by the scalar.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} multiplicand the value to multiply the duration by, positive or negative\n * @return {@code Duration} based on this duration multiplied by the specified scalar, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n multipliedBy(multiplicand) {\n if (multiplicand === 0) {\n return Duration.ZERO;\n }\n if (multiplicand === 1) {\n return this;\n }\n return Duration.create(MathUtil.safeMultiply(this.toSeconds(), multiplicand));\n }\n\n /**\n * Returns a copy of this duration divided by the specified value.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Number} divisor the value to divide the duration by, positive or negative, not zero\n * @return {@code Duration} based on this duration divided by the specified divisor, not null\n * @throws ArithmeticException if the divisor is zero or if numeric overflow occurs\n */\n dividedBy(divisor) {\n if (divisor === 0) {\n throw new ArithmeticException('Cannot divide by zero');\n }\n if (divisor === 1) {\n return this;\n }\n return Duration.create(this.toSeconds() / divisor);\n }\n\n /**\n * Converts this duration to the total length in seconds and\n * fractional nanoseconds expressed as a {@code BigDecimal}.\n *\n * @return {Number} the total length of the duration in seconds, with a scale of 9, not null\n */\n toSeconds() {\n var nanoFloat = MathUtil.safeMultiply(this._nanos, Math.pow(10, -9));\n return MathUtil.safeAdd(this._seconds, nanoFloat);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this duration with the length negated.\n * \n * This method swaps the sign of the total length of this duration.\n * For example, {@code PT1.3S} will be returned as {@code PT-1.3S}.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @return {@code Duration} based on this duration with the amount negated, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n negated() {\n return this.multipliedBy(-1);\n }\n\n /**\n * Returns a copy of this duration with a positive length.\n * \n * This method returns a positive duration by effectively removing the sign from any negative total length.\n * For example, {@code PT-1.3S} will be returned as {@code PT1.3S}.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @return {@code Duration} based on this duration with an absolute length, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n abs() {\n return this.isNegative() ? this.negated() : this;\n }\n\n //-------------------------------------------------------------------------\n /**\n * Adds this duration to the specified temporal object.\n * \n * This returns a temporal object of the same observable type as the input\n * with this duration added.\n * \n * In most cases, it is clearer to reverse the calling pattern by using\n * {@link Temporal#plus(TemporalAmount)}.\n * \n * The calculation will add the seconds, then nanos.\n * Only non-zero amounts will be added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Temporal} temporal the temporal object to adjust, not null\n * @return {Temporal} an object of the same type with the adjustment made, not null\n * @throws DateTimeException if unable to add\n * @throws ArithmeticException if numeric overflow occurs\n */\n addTo(temporal) {\n requireNonNull(temporal, 'temporal');\n if (this._seconds !== 0) {\n temporal = temporal.plus(this._seconds, ChronoUnit.SECONDS);\n }\n if (this._nanos !== 0) {\n temporal = temporal.plus(this._nanos, ChronoUnit.NANOS);\n }\n return temporal;\n }\n\n /**\n * Subtracts this duration from the specified temporal object.\n * \n * This returns a temporal object of the same observable type as the input\n * with this duration subtracted.\n * \n * In most cases, it is clearer to reverse the calling pattern by using\n * {@link Temporal#minus(TemporalAmount)}.\n * \n * The calculation will subtract the seconds, then nanos.\n * Only non-zero amounts will be added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {Temporal} temporal the temporal object to adjust, not null\n * @return {Temporal} an object of the same type with the adjustment made, not null\n * @throws DateTimeException if unable to subtract\n * @throws ArithmeticException if numeric overflow occurs\n */\n subtractFrom(temporal) {\n requireNonNull(temporal, 'temporal');\n if (this._seconds !== 0) {\n temporal = temporal.minus(this._seconds, ChronoUnit.SECONDS);\n }\n if (this._nanos !== 0) {\n temporal = temporal.minus(this._nanos, ChronoUnit.NANOS);\n }\n return temporal;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Gets the number of days in this duration.\n * \n * This returns the total number of days in the duration by dividing the\n * number of seconds by 86400.\n * This is based on the standard definition of a day as 24 hours.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @return the number of days in the duration, may be negative\n */\n toDays() {\n return this._seconds / LocalTime.SECONDS_PER_DAY;\n }\n\n /**\n * Gets the number of hours in this duration.\n * \n * This returns the total number of hours in the duration by dividing the\n * number of seconds by 3600.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @return {Number} the number of hours in the duration, may be negative\n */\n toHours() {\n return this._seconds / LocalTime.SECONDS_PER_HOUR;\n }\n\n /**\n * Gets the number of minutes in this duration.\n * \n * This returns the total number of minutes in the duration by dividing the\n * number of seconds by 60.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @return {Number} the number of minutes in the duration, may be negative\n */\n toMinutes() {\n return this._seconds / LocalTime.SECONDS_PER_MINUTE;\n }\n\n /**\n * Converts this duration to the total length in milliseconds.\n * \n * If this duration is too large to fit in a {@code long} milliseconds, then an\n * exception is thrown.\n * \n * If this duration has greater than millisecond precision, then the conversion\n * will drop any excess precision information as though the amount in nanoseconds\n * was subject to integer division by one million.\n *\n * @return {Number} the total length of the duration in milliseconds\n * @throws ArithmeticException if numeric overflow occurs\n */\n toMillis() {\n var millis = Math.round(MathUtil.safeMultiply(this._seconds, 1000));\n millis = MathUtil.safeAdd(millis, MathUtil.intDiv(this._nanos, 1000000));\n return millis;\n }\n\n /**\n * Converts this duration to the total length in nanoseconds expressed as a {@code long}.\n * \n * If this duration is too large to fit in a {@code long} nanoseconds, then an\n * exception is thrown.\n *\n * @return {Number} the total length of the duration in nanoseconds\n * @throws ArithmeticException if numeric overflow occurs\n */\n toNanos() {\n var totalNanos = MathUtil.safeMultiply(this._seconds, LocalTime.NANOS_PER_SECOND);\n totalNanos = MathUtil.safeAdd(totalNanos, this._nanos);\n return totalNanos;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Compares this duration to the specified {@code Duration}.\n * \n * The comparison is based on the total length of the durations.\n *\n * @param {Duration} otherDuration the other duration to compare to, not null\n * @return {Number} the comparator value, negative if less, positive if greater\n */\n compareTo(otherDuration) {\n requireNonNull(otherDuration, 'otherDuration');\n requireInstance(otherDuration, Duration, 'otherDuration');\n var cmp = MathUtil.compareNumbers(this._seconds, otherDuration.seconds());\n if (cmp !== 0) {\n return cmp;\n }\n return this._nanos - otherDuration.nano();\n }\n\n //-----------------------------------------------------------------------\n /**\n * Checks if this duration is equal to the specified {@code Duration}.\n * \n * The comparison is based on the total length of the durations.\n *\n * @param {Duration} otherDuration the other duration, null returns false\n * @return {boolean} true if the other duration is equal to this one\n */\n equals(otherDuration) {\n if (this === otherDuration) {\n return true;\n }\n if (otherDuration instanceof Duration) {\n return this.seconds() === otherDuration.seconds() &&\n this.nano() === otherDuration.nano();\n }\n return false;\n }\n\n //-----------------------------------------------------------------------\n /**\n * A string representation of this duration using ISO-8601 seconds\n * based representation, such as {@code PT8H6M12.345S}.\n * \n * The format of the returned string will be {@code PTnHnMnS}, where n is\n * the relevant hours, minutes or seconds part of the duration.\n * Any fractional seconds are placed after a decimal povar i the seconds section.\n * If a section has a zero value, it is omitted.\n * The hours, minutes and seconds will all have the same sign.\n * \n * Examples:\n * \n * {@code LocalTime} is an immutable date-time object that represents a time,\n * often viewed as hour-minute-second.\n * Time is represented to nanosecond precision.\n * For example, the value '13:45.30.123456789' can be stored in a {@code LocalTime}.\n * \n * It does not store or represent a date or time-zone.\n * Instead, it is a description of the local time as seen on a wall clock.\n * It cannot represent an instant on the time-line without additional information\n * such as an offset or time-zone.\n * \n * The ISO-8601 calendar system is the modern civil calendar system used today\n * in most of the world. This API assumes that all calendar systems use the same\n * representation, this class, for time-of-day.\n *\n * \n * This will query the specified clock to obtain the current time.\n * Using this method allows the use of an alternate clock for testing.\n * The alternate clock may be introduced using {@link Clock dependency injection}.\n *\n * @param clock the clock to use, not null\n * @return the current time, not null\n */\n static now(clock = Clock.systemDefaultZone()) {\n requireNonNull(clock, 'clock');\n // inline OffsetTime factory to avoid creating object and InstantProvider checks\n var now = clock.instant(); // called once\n var offset = clock.offset(now);\n var secsOfDay = MathUtil.intMod(now.epochSecond(), LocalTime.SECONDS_PER_DAY);\n secsOfDay = MathUtil.intMod((secsOfDay + offset.totalSeconds()), LocalTime.SECONDS_PER_DAY);\n if (secsOfDay < 0) {\n secsOfDay += LocalTime.SECONDS_PER_DAY;\n }\n return LocalTime.ofSecondOfDay(secsOfDay, now.nano());\n }\n\n /**\n * Obtains an instance of {@code LocalTime} from an hour, minute, second and nanosecond.\n * \n * This factory may return a cached value, but applications must not rely on this.\n *\n * @param hour the hour-of-day to represent, from 0 to 23\n * @param minute the minute-of-hour to represent, from 0 to 59\n * @param second the second-of-minute to represent, from 0 to 59\n * @param nanoOfSecond the nano-of-second to represent, from 0 to 999,999,999\n * @return the local time, not null\n * @throws DateTimeException if the value of any field is out of range\n */\n static of(hour, minute, second, nanoOfSecond) {\n return new LocalTime(hour, minute, second, nanoOfSecond);\n }\n\n /**\n * Obtains an instance of {@code LocalTime} from a second-of-day value, with\n * associated nanos of second.\n * \n * This factory may return a cached value, but applications must not rely on this.\n *\n * @param secondOfDay the second-of-day, from {@code 0} to {@code 24 * 60 * 60 - 1}\n * @param nanoOfSecond the nano-of-second, from 0 to 999,999,999\n * @return the local time, not null\n * @throws DateTimeException if the either input value is invalid\n */\n static ofSecondOfDay(secondOfDay=0, nanoOfSecond=0) {\n ChronoField.SECOND_OF_DAY.checkValidValue(secondOfDay);\n ChronoField.NANO_OF_SECOND.checkValidValue(nanoOfSecond);\n var hours = MathUtil.intDiv(secondOfDay, LocalTime.SECONDS_PER_HOUR);\n secondOfDay -= hours * LocalTime.SECONDS_PER_HOUR;\n var minutes = MathUtil.intDiv(secondOfDay, LocalTime.SECONDS_PER_MINUTE);\n secondOfDay -= minutes * LocalTime.SECONDS_PER_MINUTE;\n return new LocalTime(hours, minutes, secondOfDay, nanoOfSecond);\n }\n \n /**\n * Obtains an instance of {@code LocalTime} from a nanos-of-day value.\n * \n * This factory may return a cached value, but applications must not rely on this.\n *\n * @param nanoOfDay the nano of day, from {@code 0} to {@code 24 * 60 * 60 * 1,000,000,000 - 1}\n * @return the local time, not null\n * @throws DateTimeException if the nanos of day value is invalid\n */\n static ofNanoOfDay(nanoOfDay=0) {\n ChronoField.NANO_OF_DAY.checkValidValue(nanoOfDay);\n var hours = MathUtil.intDiv(nanoOfDay, LocalTime.NANOS_PER_HOUR);\n nanoOfDay -= hours * LocalTime.NANOS_PER_HOUR;\n var minutes = MathUtil.intDiv(nanoOfDay, LocalTime.NANOS_PER_MINUTE);\n nanoOfDay -= minutes * LocalTime.NANOS_PER_MINUTE;\n var seconds = MathUtil.intDiv(nanoOfDay, LocalTime.NANOS_PER_SECOND);\n nanoOfDay -= seconds * LocalTime.NANOS_PER_SECOND;\n return new LocalTime(hours, minutes, seconds, nanoOfDay);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains an instance of {@code LocalTime} from a temporal object.\n * \n * A {@code TemporalAccessor} represents some form of date and time information.\n * This factory converts the arbitrary temporal object to an instance of {@code LocalTime}.\n * \n * The conversion uses the {@link TemporalQueries#localTime()} query, which relies\n * on extracting the {@link ChronoField#NANO_OF_DAY NANO_OF_DAY} field.\n * \n * This method matches the signature of the functional interface {@link TemporalQuery}\n * allowing it to be used in queries via method reference, {@code LocalTime::from}.\n *\n * @param temporal the temporal object to convert, not null\n * @return the local time, not null\n * @throws DateTimeException if unable to convert to a {@code LocalTime}\n */\n static from(temporal) {\n requireNonNull(temporal, 'temporal');\n var time = temporal.query(TemporalQueries.localTime());\n if (time == null) {\n throw new DateTimeException('Unable to obtain LocalTime from TemporalAccessor: ' +\n temporal + ', type ' + temporal);\n }\n return time;\n }\n\n /**\n * Obtains an instance of {@code LocalTime} from a text string using a specific formatter.\n * \n * The text is parsed using the formatter, returning a time.\n *\n * @param text the text to parse, not null\n * @param formatter the formatter to use, not null\n * @return the parsed local time, not null\n * @throws DateTimeParseException if the text cannot be parsed\n */\n static parse(text, formatter=DateTimeFormatter.ISO_LOCAL_TIME) {\n requireNonNull(formatter, 'formatter');\n return formatter.parse(text, LocalTime.FROM);\n }\n\n /**\n * Constructor, previously validated.\n *\n * @param hour the hour-of-day to represent, validated from 0 to 23\n * @param minute the minute-of-hour to represent, validated from 0 to 59\n * @param second the second-of-minute to represent, validated from 0 to 59\n * @param nanoOfSecond the nano-of-second to represent, validated from 0 to 999,999,999\n */\n constructor(hour=0, minute=0, second=0, nanoOfSecond=0) {\n super();\n LocalTime._validate(hour, minute, second, nanoOfSecond);\n if ((minute | second | nanoOfSecond) === 0) {\n return LocalTime.HOURS[hour];\n }\n this._hour = hour;\n this._minute = minute;\n this._second = second;\n this._nano = nanoOfSecond;\n }\n\n static _validate(hour, minute, second, nanoOfSecond){\n ChronoField.HOUR_OF_DAY.checkValidValue(hour);\n ChronoField.MINUTE_OF_HOUR.checkValidValue(minute);\n ChronoField.SECOND_OF_MINUTE.checkValidValue(second);\n ChronoField.NANO_OF_SECOND.checkValidValue(nanoOfSecond);\n \n }\n //-----------------------------------------------------------------------\n /**\n * Checks if the specified field is supported.\n * \n * This checks if this time can be queried for the specified field.\n * If false, then calling the {@link #range(TemporalField) range} and\n * {@link #get(TemporalField) get} methods will throw an exception.\n * \n * If the field is a {@link ChronoField} then the query is implemented here.\n * The supported fields are:\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}\n * passing {@code this} as the argument.\n * Whether the field is supported is determined by the field.\n *\n * @param fieldOrUnit the field to check, null returns false\n * @return true if the field is supported on this time, false if not\n */\n isSupported(fieldOrUnit) {\n if (fieldOrUnit instanceof ChronoField) {\n return fieldOrUnit.isTimeBased();\n } else if (fieldOrUnit instanceof ChronoUnit) {\n return fieldOrUnit.isTimeBased();\n }\n return fieldOrUnit != null && fieldOrUnit.isSupportedBy(this);\n }\n\n /**\n * Gets the range of valid values for the specified field.\n * \n * The range object expresses the minimum and maximum valid values for a field.\n * This time is used to enhance the accuracy of the returned range.\n * If it is not possible to return the range, because the field is not supported\n * or for some other reason, an exception is thrown.\n * \n * If the field is a {@link ChronoField} then the query is implemented here.\n * The {@link #isSupported(TemporalField) supported fields} will return\n * appropriate range instances.\n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)}\n * passing {@code this} as the argument.\n * Whether the range can be obtained is determined by the field.\n *\n * @param field the field to query the range for, not null\n * @return the range of valid values for the field, not null\n * @throws DateTimeException if the range for the field cannot be obtained\n */\n range(field) {\n requireNonNull(field);\n return super.range(field);\n }\n\n /**\n * Gets the value of the specified field from this time as an {@code int}.\n * \n * This queries this time for the value for the specified field.\n * The returned value will always be within the valid range of values for the field.\n * If it is not possible to return the value, because the field is not supported\n * or for some other reason, an exception is thrown.\n * \n * If the field is a {@link ChronoField} then the query is implemented here.\n * The {@link #isSupported(TemporalField) supported fields} will return valid\n * values based on this time, except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY}\n * which are too large to fit in an {@code int} and throw a {@code DateTimeException}.\n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}\n * passing {@code this} as the argument. Whether the value can be obtained,\n * and what the value represents, is determined by the field.\n *\n * @param field the field to get, not null\n * @return the value for the field\n * @throws DateTimeException if a value for the field cannot be obtained\n * @throws ArithmeticException if numeric overflow occurs\n */\n get(field) {\n return this.getLong(field);\n }\n\n /**\n * Gets the value of the specified field from this time as a {@code long}.\n * \n * This queries this time for the value for the specified field.\n * If it is not possible to return the value, because the field is not supported\n * or for some other reason, an exception is thrown.\n * \n * If the field is a {@link ChronoField} then the query is implemented here.\n * The {@link #isSupported(TemporalField) supported fields} will return valid\n * values based on this time.\n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}\n * passing {@code this} as the argument. Whether the value can be obtained,\n * and what the value represents, is determined by the field.\n *\n * @param field the field to get, not null\n * @return the value for the field\n * @throws DateTimeException if a value for the field cannot be obtained\n * @throws ArithmeticException if numeric overflow occurs\n */\n getLong(field) {\n requireNonNull(field, 'field');\n if (field instanceof ChronoField) {\n return this._get0(field);\n }\n return field.getFrom(this);\n }\n\n _get0(field) {\n switch (field) {\n case ChronoField.NANO_OF_SECOND: return this._nano;\n case ChronoField.NANO_OF_DAY: return this.toNanoOfDay();\n case ChronoField.MICRO_OF_SECOND: return MathUtil.intDiv(this._nano, 1000);\n case ChronoField.MICRO_OF_DAY: return MathUtil.intDiv(this.toNanoOfDay(), 1000);\n case ChronoField.MILLI_OF_SECOND: return MathUtil.intDiv(this._nano, 1000000);\n case ChronoField.MILLI_OF_DAY: return MathUtil.intDiv(this.toNanoOfDay(), 1000000);\n case ChronoField.SECOND_OF_MINUTE: return this._second;\n case ChronoField.SECOND_OF_DAY: return this.toSecondOfDay();\n case ChronoField.MINUTE_OF_HOUR: return this._minute;\n case ChronoField.MINUTE_OF_DAY: return this._hour * 60 + this._minute;\n case ChronoField.HOUR_OF_AMPM: return this._hour % 12;\n case ChronoField.CLOCK_HOUR_OF_AMPM: var ham = MathUtil.intMod(this._hour, 12); return (ham % 12 === 0 ? 12 : ham);\n case ChronoField.HOUR_OF_DAY: return this._hour;\n case ChronoField.CLOCK_HOUR_OF_DAY: return (this._hour === 0 ? 24 : this._hour);\n case ChronoField.AMPM_OF_DAY: return this._hour / 12;\n }\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Gets the hour-of-day field.\n *\n * @return the hour-of-day, from 0 to 23\n */\n hour() {\n return this._hour;\n }\n\n /**\n * Gets the minute-of-hour field.\n *\n * @return the minute-of-hour, from 0 to 59\n */\n minute() {\n return this._minute;\n }\n\n /**\n * Gets the second-of-minute field.\n *\n * @return the second-of-minute, from 0 to 59\n */\n second() {\n return this._second;\n }\n\n /**\n * Gets the nano-of-second field.\n *\n * @return the nano-of-second, from 0 to 999,999,999\n */\n nano() {\n return this._nano;\n }\n\n /**\n * functional overloading for with\n */\n with(){\n if(arguments.length < 2){\n return this._with1.apply(this, arguments);\n } else {\n return this._with2.apply(this, arguments);\n }\n }\n\n /**\n * Returns an adjusted copy of this time.\n * \n * This returns a new {@code LocalTime}, based on this one, with the time adjusted.\n * The adjustment takes place using the specified adjuster strategy object.\n * Read the documentation of the adjuster to understand what adjustment will be made.\n * \n * A simple adjuster might simply set the one of the fields, such as the hour field.\n * A more complex adjuster might set the time to the last hour of the day.\n * \n * The result of this method is obtained by invoking the\n * {@link TemporalAdjuster#adjustInto(Temporal)} method on the\n * specified adjuster passing {@code this} as the argument.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param adjuster the adjuster to use, not null\n * @return a {@code LocalTime} based on {@code this} with the adjustment made, not null\n * @throws DateTimeException if the adjustment cannot be made\n * @throws ArithmeticException if numeric overflow occurs\n */\n _with1(adjuster) {\n requireNonNull(adjuster, 'adjuster');\n // optimizations\n if (adjuster instanceof LocalTime) {\n return adjuster;\n }\n assert(typeof adjuster.adjustInto === 'function', 'adjuster', IllegalArgumentException);\n return adjuster.adjustInto(this);\n }\n\n /**\n * Returns a copy of this time with the specified field set to a new value.\n * \n * This returns a new {@code LocalTime}, based on this one, with the value\n * for the specified field changed.\n * This can be used to change any supported field, such as the hour, minute or second.\n * If it is not possible to set the value, because the field is not supported or for\n * some other reason, an exception is thrown.\n * \n * If the field is a {@link ChronoField} then the adjustment is implemented here.\n * The supported fields behave as follows:\n * \n * In all cases, if the new value is outside the valid range of values for the field\n * then a {@code DateTimeException} will be thrown.\n * \n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.adjustInto(Temporal, long)}\n * passing {@code this} as the argument. In this case, the field determines\n * whether and how to adjust the instant.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param field the field to set in the result, not null\n * @param newValue the new value of the field in the result\n * @return a {@code LocalTime} based on {@code this} with the specified field set, not null\n * @throws DateTimeException if the field cannot be set\n * @throws ArithmeticException if numeric overflow occurs\n */\n _with2(field, newValue) {\n requireNonNull(field, 'field');\n if (field instanceof ChronoField) {\n field.checkValidValue(newValue);\n switch (field) {\n case ChronoField.NANO_OF_SECOND: return this.withNano(newValue);\n case ChronoField.NANO_OF_DAY: return LocalTime.ofNanoOfDay(newValue);\n case ChronoField.MICRO_OF_SECOND: return this.withNano(newValue * 1000);\n case ChronoField.MICRO_OF_DAY: return LocalTime.ofNanoOfDay(newValue * 1000);\n case ChronoField.MILLI_OF_SECOND: return this.withNano( newValue * 1000000);\n case ChronoField.MILLI_OF_DAY: return LocalTime.ofNanoOfDay(newValue * 1000000);\n case ChronoField.SECOND_OF_MINUTE: return this.withSecond(newValue);\n case ChronoField.SECOND_OF_DAY: return this.plusSeconds(newValue - this.toSecondOfDay());\n case ChronoField.MINUTE_OF_HOUR: return this.withMinute(newValue);\n case ChronoField.MINUTE_OF_DAY: return this.plusMinutes(newValue - (this._hour * 60 + this._minute));\n case ChronoField.HOUR_OF_AMPM: return this.plusHours(newValue - MathUtil.intMod(this._hour, 12));\n case ChronoField.CLOCK_HOUR_OF_AMPM: return this.plusHours((newValue === 12 ? 0 : newValue) - MathUtil.intMod(this._hour, 12));\n case ChronoField.HOUR_OF_DAY: return this.withHour(newValue);\n case ChronoField.CLOCK_HOUR_OF_DAY: return this.withHour((newValue === 24 ? 0 : newValue));\n case ChronoField.AMPM_OF_DAY: return this.plusHours((newValue - MathUtil.intDiv(this._hour, 12)) * 12);\n }\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n return field.adjustInto(this, newValue);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this {@code LocalTime} with the hour-of-day value altered.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param hour the hour-of-day to set in the result, from 0 to 23\n * @return a {@code LocalTime} based on this time with the requested hour, not null\n * @throws DateTimeException if the hour value is invalid\n */\n withHour(hour=0) {\n if (this._hour === hour) {\n return this;\n }\n return new LocalTime(hour, this._minute, this._second, this._nano);\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the minute-of-hour value altered.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param minute the minute-of-hour to set in the result, from 0 to 59\n * @return a {@code LocalTime} based on this time with the requested minute, not null\n * @throws DateTimeException if the minute value is invalid\n */\n withMinute(minute=0) {\n if (this._minute === minute) {\n return this;\n }\n return new LocalTime(this._hour, minute, this._second, this._nano);\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the second-of-minute value altered.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param second the second-of-minute to set in the result, from 0 to 59\n * @return a {@code LocalTime} based on this time with the requested second, not null\n * @throws DateTimeException if the second value is invalid\n */\n withSecond(second=0) {\n if (this._second === second) {\n return this;\n }\n return new LocalTime(this._hour, this._minute, second, this._nano);\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the nano-of-second value altered.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param nanoOfSecond the nano-of-second to set in the result, from 0 to 999,999,999\n * @return a {@code LocalTime} based on this time with the requested nanosecond, not null\n * @throws DateTimeException if the nanos value is invalid\n */\n withNano(nanoOfSecond) {\n if (this._nano === nanoOfSecond) {\n return this;\n }\n return new LocalTime(this._hour, this._minute, this._second, nanoOfSecond);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this {@code LocalTime} with the time truncated.\n * \n * Truncating the time returns a copy of the original time with fields\n * smaller than the specified unit set to zero.\n * For example, truncating with the {@link ChronoUnit#MINUTES minutes} unit\n * will set the second-of-minute and nano-of-second field to zero.\n * \n * The unit must have a {@linkplain TemporalUnit#getDuration() duration}\n * that divides into the length of a standard day without remainder.\n * This includes all supplied time units on {@link ChronoUnit} and\n * {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param unit the unit to truncate to, not null\n * @return a {@code LocalTime} based on this time with the time truncated, not null\n * @throws DateTimeException if unable to truncate\n */\n truncatedTo(unit) {\n requireNonNull(unit, 'unit');\n if (unit === ChronoUnit.NANOS) {\n return this;\n }\n var unitDur = unit.duration();\n if (unitDur.seconds() > LocalTime.SECONDS_PER_DAY) {\n throw new DateTimeException('Unit is too large to be used for truncation');\n }\n var dur = unitDur.toNanos();\n if (MathUtil.intMod(LocalTime.NANOS_PER_DAY, dur) !== 0) {\n throw new DateTimeException('Unit must divide into a standard day without remainder');\n }\n var nod = this.toNanoOfDay();\n return LocalTime.ofNanoOfDay(MathUtil.intDiv(nod, dur) * dur);\n }\n\n //-----------------------------------------------------------------------\n\n plus(){\n if(arguments.length < 2){\n return this._plus1.apply(this, arguments);\n } else {\n return this._plus2.apply(this, arguments);\n }\n }\n /**\n * Returns a copy of this date with the specified period added.\n * \n * This method returns a new time based on this time with the specified period added.\n * The amount is typically {@link Period} but may be any other type implementing\n * the {@link TemporalAmount} interface.\n * The calculation is delegated to the specified adjuster, which typically calls\n * back to {@link #plus(long, TemporalUnit)}.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amount the amount to add, not null\n * @return a {@code LocalTime} based on this time with the addition made, not null\n * @throws DateTimeException if the addition cannot be made\n * @throws ArithmeticException if numeric overflow occurs\n */\n _plus1(amount) {\n requireNonNull(amount, 'amount');\n return amount.addTo(this);\n }\n\n /**\n * Returns a copy of this time with the specified period added.\n * \n * This method returns a new time based on this time with the specified period added.\n * This can be used to add any period that is defined by a unit, for example to add hours, minutes or seconds.\n * The unit is responsible for the details of the calculation, including the resolution\n * of any edge cases in the calculation.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amountToAdd the amount of the unit to add to the result, may be negative\n * @param unit the unit of the period to add, not null\n * @return a {@code LocalTime} based on this time with the specified period added, not null\n * @throws DateTimeException if the unit cannot be added to this type\n */\n _plus2(amountToAdd, unit) {\n requireNonNull(unit, 'unit');\n if (unit instanceof ChronoUnit) {\n switch (unit) {\n case ChronoUnit.NANOS: return this.plusNanos(amountToAdd);\n case ChronoUnit.MICROS: return this.plusNanos(MathUtil.intMod(amountToAdd, LocalTime.MICROS_PER_DAY) * 1000);\n case ChronoUnit.MILLIS: return this.plusNanos(MathUtil.intMod(amountToAdd, LocalTime.MILLIS_PER_DAY) * 1000000);\n case ChronoUnit.SECONDS: return this.plusSeconds(amountToAdd);\n case ChronoUnit.MINUTES: return this.plusMinutes(amountToAdd);\n case ChronoUnit.HOURS: return this.plusHours(amountToAdd);\n case ChronoUnit.HALF_DAYS: return this.plusHours(MathUtil.intMod(amountToAdd, 2) * 12);\n }\n throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);\n }\n return unit.addTo(this, amountToAdd);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this {@code LocalTime} with the specified period in hours added.\n * \n * This adds the specified number of hours to this time, returning a new time.\n * The calculation wraps around midnight.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param hoursToAdd the hours to add, may be negative\n * @return a {@code LocalTime} based on this time with the hours added, not null\n */\n plusHours(hoursToAdd) {\n if (hoursToAdd === 0) {\n return this;\n }\n\n var newHour = MathUtil.intMod(MathUtil.intMod(hoursToAdd, LocalTime.HOURS_PER_DAY) + this._hour + LocalTime.HOURS_PER_DAY, LocalTime.HOURS_PER_DAY);\n return new LocalTime(newHour, this._minute, this._second, this._nano);\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the specified period in minutes added.\n * \n * This adds the specified number of minutes to this time, returning a new time.\n * The calculation wraps around midnight.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param minutesToAdd the minutes to add, may be negative\n * @return a {@code LocalTime} based on this time with the minutes added, not null\n */\n plusMinutes(minutesToAdd) {\n if (minutesToAdd === 0) {\n return this;\n }\n var mofd = this._hour * LocalTime.MINUTES_PER_HOUR + this._minute;\n var newMofd = MathUtil.intMod(MathUtil.intMod(minutesToAdd, LocalTime.MINUTES_PER_DAY) + mofd + LocalTime.MINUTES_PER_DAY, LocalTime.MINUTES_PER_DAY);\n if (mofd === newMofd) {\n return this;\n }\n var newHour = MathUtil.intDiv(newMofd, LocalTime.MINUTES_PER_HOUR);\n var newMinute = MathUtil.intMod(newMofd, LocalTime.MINUTES_PER_HOUR);\n return new LocalTime(newHour, newMinute, this._second, this._nano);\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the specified period in seconds added.\n * \n * This adds the specified number of seconds to this time, returning a new time.\n * The calculation wraps around midnight.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param secondstoAdd the seconds to add, may be negative\n * @return a {@code LocalTime} based on this time with the seconds added, not null\n */\n plusSeconds(secondstoAdd) {\n if (secondstoAdd === 0) {\n return this;\n }\n var sofd = this._hour * LocalTime.SECONDS_PER_HOUR +\n this._minute * LocalTime.SECONDS_PER_MINUTE + this._second;\n var newSofd = MathUtil.intMod((MathUtil.intMod(secondstoAdd, LocalTime.SECONDS_PER_DAY) + sofd + LocalTime.SECONDS_PER_DAY), LocalTime.SECONDS_PER_DAY);\n if (sofd === newSofd) {\n return this;\n }\n var newHour = MathUtil.intDiv(newSofd, LocalTime.SECONDS_PER_HOUR);\n var newMinute = MathUtil.intMod(MathUtil.intDiv(newSofd, LocalTime.SECONDS_PER_MINUTE), LocalTime.MINUTES_PER_HOUR);\n var newSecond = MathUtil.intMod(newSofd, LocalTime.SECONDS_PER_MINUTE);\n return new LocalTime(newHour, newMinute, newSecond, this._nano);\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the specified period in nanoseconds added.\n * \n * This adds the specified number of nanoseconds to this time, returning a new time.\n * The calculation wraps around midnight.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param nanosToAdd the nanos to add, may be negative\n * @return a {@code LocalTime} based on this time with the nanoseconds added, not null\n */\n plusNanos(nanosToAdd) {\n if (nanosToAdd === 0) {\n return this;\n }\n var nofd = this.toNanoOfDay();\n var newNofd = MathUtil.intMod((MathUtil.intMod(nanosToAdd, LocalTime.NANOS_PER_DAY) + nofd + LocalTime.NANOS_PER_DAY), LocalTime.NANOS_PER_DAY);\n if (nofd === newNofd) {\n return this;\n }\n var newHour = MathUtil.intDiv(newNofd, LocalTime.NANOS_PER_HOUR);\n var newMinute = MathUtil.intMod(MathUtil.intDiv(newNofd, LocalTime.NANOS_PER_MINUTE), LocalTime.MINUTES_PER_HOUR);\n var newSecond = MathUtil.intMod(MathUtil.intDiv(newNofd, LocalTime.NANOS_PER_SECOND), LocalTime.SECONDS_PER_MINUTE);\n var newNano = MathUtil.intMod(newNofd, LocalTime.NANOS_PER_SECOND);\n return new LocalTime(newHour, newMinute, newSecond, newNano);\n }\n\n //-----------------------------------------------------------------------\n minus(){\n if(arguments.length < 2){\n return this._minus1.apply(this, arguments);\n } else {\n return this._minus2.apply(this, arguments);\n }\n }\n /**\n * Returns a copy of this time with the specified period subtracted.\n * \n * This method returns a new time based on this time with the specified period subtracted.\n * The amount is typically {@link Period} but may be any other type implementing\n * the {@link TemporalAmount} interface.\n * The calculation is delegated to the specified adjuster, which typically calls\n * back to {@link #minus(long, TemporalUnit)}.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amount the amount to subtract, not null\n * @return a {@code LocalTime} based on this time with the subtraction made, not null\n * @throws DateTimeException if the subtraction cannot be made\n * @throws ArithmeticException if numeric overflow occurs\n */\n\n _minus1(amount) {\n requireNonNull(amount, 'amount');\n return amount.subtractFrom(this);\n }\n\n /**\n * Returns a copy of this time with the specified period subtracted.\n * \n * This method returns a new time based on this time with the specified period subtracted.\n * This can be used to subtract any period that is defined by a unit, for example to subtract hours, minutes or seconds.\n * The unit is responsible for the details of the calculation, including the resolution\n * of any edge cases in the calculation.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amountToSubtract the amount of the unit to subtract from the result, may be negative\n * @param unit the unit of the period to subtract, not null\n * @return a {@code LocalTime} based on this time with the specified period subtracted, not null\n * @throws DateTimeException if the unit cannot be added to this type\n */\n _minus2(amountToSubtract, unit) {\n requireNonNull(unit, 'unit');\n return this._plus2(-1 * amountToSubtract, unit);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this {@code LocalTime} with the specified period in hours subtracted.\n * \n * This subtracts the specified number of hours from this time, returning a new time.\n * The calculation wraps around midnight.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param hoursToSubtract the hours to subtract, may be negative\n * @return a {@code LocalTime} based on this time with the hours subtracted, not null\n */\n minusHours(hoursToSubtract) {\n return this.plusHours(-1 * MathUtil.intMod(hoursToSubtract, LocalTime.HOURS_PER_DAY));\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the specified period in minutes subtracted.\n * \n * This subtracts the specified number of minutes from this time, returning a new time.\n * The calculation wraps around midnight.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param minutesToSubtract the minutes to subtract, may be negative\n * @return a {@code LocalTime} based on this time with the minutes subtracted, not null\n */\n minusMinutes(minutesToSubtract) {\n return this.plusMinutes(-1 * MathUtil.intMod(minutesToSubtract, LocalTime.MINUTES_PER_DAY));\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the specified period in seconds subtracted.\n * \n * This subtracts the specified number of seconds from this time, returning a new time.\n * The calculation wraps around midnight.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param secondsToSubtract the seconds to subtract, may be negative\n * @return a {@code LocalTime} based on this time with the seconds subtracted, not null\n */\n minusSeconds(secondsToSubtract) {\n return this.plusSeconds(-1 * MathUtil.intMod(secondsToSubtract, LocalTime.SECONDS_PER_DAY));\n }\n\n /**\n * Returns a copy of this {@code LocalTime} with the specified period in nanoseconds subtracted.\n * \n * This subtracts the specified number of nanoseconds from this time, returning a new time.\n * The calculation wraps around midnight.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param nanosToSubtract the nanos to subtract, may be negative\n * @return a {@code LocalTime} based on this time with the nanoseconds subtracted, not null\n */\n minusNanos(nanosToSubtract) {\n return this.plusNanos(-1 * MathUtil.intMod(nanosToSubtract, LocalTime.NANOS_PER_DAY));\n }\n\n //-----------------------------------------------------------------------\n /**\n * Queries this time using the specified query.\n * \n * This queries this time using the specified query strategy object.\n * The {@code TemporalQuery} object defines the logic to be used to\n * obtain the result. Read the documentation of the query to understand\n * what the result of this method will be.\n * \n * The result of this method is obtained by invoking the\n * {@link TemporalQuery#queryFrom(TemporalAccessor)} method on the\n * specified query passing {@code this} as the argument.\n *\n * @param query the query to invoke, not null\n * @return the query result, null may be returned (defined by the query)\n * @throws DateTimeException if unable to query (defined by the query)\n * @throws ArithmeticException if numeric overflow occurs (defined by the query)\n */\n query(query) {\n requireNonNull(query, 'query');\n if (query === TemporalQueries.precision()) {\n return ChronoUnit.NANOS;\n } else if (query === TemporalQueries.localTime()) {\n return this;\n }\n // inline TemporalAccessor.super.query(query) as an optimization\n if (query === TemporalQueries.chronology() || query === TemporalQueries.zoneId() ||\n query === TemporalQueries.zone() || query === TemporalQueries.offset() ||\n query === TemporalQueries.localDate()) {\n return null;\n }\n return query.queryFrom(this);\n }\n\n /**\n * Adjusts the specified temporal object to have the same time as this object.\n * \n * This returns a temporal object of the same observable type as the input\n * with the time changed to be the same as this.\n * \n * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}\n * passing {@link ChronoField#NANO_OF_DAY} as the field.\n * \n * In most cases, it is clearer to reverse the calling pattern by using\n * {@link Temporal#with(TemporalAdjuster)}:\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param temporal the target object to be adjusted, not null\n * @return the adjusted object, not null\n * @throws DateTimeException if unable to make the adjustment\n * @throws ArithmeticException if numeric overflow occurs\n */\n adjustInto(temporal) {\n return temporal.with(LocalTime.NANO_OF_DAY, this.toNanoOfDay());\n }\n\n /**\n * Calculates the period between this time and another time in\n * terms of the specified unit.\n * \n * This calculates the period between two times in terms of a single unit.\n * The start and end points are {@code this} and the specified time.\n * The result will be negative if the end is before the start.\n * The {@code Temporal} passed to this method must be a {@code LocalTime}.\n * For example, the period in hours between two times can be calculated\n * using {@code startTime.until(endTime, HOURS)}.\n * \n * The calculation returns a whole number, representing the number of\n * complete units between the two times.\n * For example, the period in hours between 11:30 and 13:29 will only\n * be one hour as it is one minute short of two hours.\n * \n * This method operates in association with {@link TemporalUnit#between}.\n * The result of this method is a {@code long} representing the amount of\n * the specified unit. By contrast, the result of {@code between} is an\n * object that can be used directly in addition/subtraction:\n * \n * The calculation is implemented in this method for {@link ChronoUnit}.\n * The units {@code NANOS}, {@code MICROS}, {@code MILLIS}, {@code SECONDS},\n * {@code MINUTES}, {@code HOURS} and {@code HALF_DAYS} are supported.\n * Other {@code ChronoUnit} values will throw an exception.\n * \n * If the unit is not a {@code ChronoUnit}, then the result of this method\n * is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)}\n * passing {@code this} as the first argument and the input temporal as\n * the second argument.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param endExclusive the end time, which is converted to a {@code LocalTime}, not null\n * @param unit the unit to measure the period in, not null\n * @return the amount of the period between this time and the end time\n * @throws DateTimeException if the period cannot be calculated\n * @throws ArithmeticException if numeric overflow occurs\n */\n until(endExclusive, unit) {\n var end = LocalTime.from(endExclusive);\n if (unit instanceof ChronoUnit) {\n var nanosUntil = end.toNanoOfDay() - this.toNanoOfDay(); // no overflow\n switch (unit) {\n case ChronoUnit.NANOS: return nanosUntil;\n case ChronoUnit.MICROS: return MathUtil.intDiv(nanosUntil, 1000);\n case ChronoUnit.MILLIS: return MathUtil.intDiv(nanosUntil, 1000000);\n case ChronoUnit.SECONDS: return MathUtil.intDiv(nanosUntil, LocalTime.NANOS_PER_SECOND);\n case ChronoUnit.MINUTES: return MathUtil.intDiv(nanosUntil, LocalTime.NANOS_PER_MINUTE);\n case ChronoUnit.HOURS: return MathUtil.intDiv(nanosUntil, LocalTime.NANOS_PER_HOUR);\n case ChronoUnit.HALF_DAYS: return MathUtil.intDiv(nanosUntil, (12 * LocalTime.NANOS_PER_HOUR));\n }\n throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);\n }\n return unit.between(this, end);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Combines this time with a date to create a {@code LocalDateTime}.\n * \n * This returns a {@code LocalDateTime} formed from this time at the specified date.\n * All possible combinations of date and time are valid.\n *\n * @param date the date to combine with, not null\n * @return the local date-time formed from this time and the specified date, not null\n */\n atDate(date) {\n return LocalDateTime.of(date, this);\n }\n\n /**\n * Combines this time with an offset to create an {@code OffsetTime}.\n * \n * This returns an {@code OffsetTime} formed from this time at the specified offset.\n * All possible combinations of time and offset are valid.\n *\n * @param offset the offset to combine with, not null\n * @return the offset time formed from this time and the specified offset, not null\n */\n atOffset(offset) {\n return OffsetTime.of(this, offset);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Extracts the time as seconds of day,\n * from {@code 0} to {@code 24 * 60 * 60 - 1}.\n *\n * @return the second-of-day equivalent to this time\n */\n toSecondOfDay() {\n var total = this._hour * LocalTime.SECONDS_PER_HOUR;\n total += this._minute * LocalTime.SECONDS_PER_MINUTE;\n total += this._second;\n return total;\n }\n\n /**\n * Extracts the time as nanos of day,\n * from {@code 0} to {@code 24 * 60 * 60 * 1,000,000,000 - 1}.\n *\n * @return the nano of day equivalent to this time\n */\n toNanoOfDay() {\n var total = this._hour * LocalTime.NANOS_PER_HOUR;\n total += this._minute * LocalTime.NANOS_PER_MINUTE;\n total += this._second * LocalTime.NANOS_PER_SECOND;\n total += this._nano;\n return total;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Compares this {@code LocalTime} to another time.\n * \n * The comparison is based on the time-line position of the local times within a day.\n * It is 'consistent with equals', as defined by {@link Comparable}.\n *\n * @param other the other time to compare to, not null\n * @return the comparator value, negative if less, positive if greater\n * @throws NullPointerException if {@code other} is null\n */\n compareTo(other) {\n requireNonNull(other, 'other');\n requireInstance(other, LocalTime, 'other');\n var cmp = MathUtil.compareNumbers(this._hour, other._hour);\n if (cmp === 0) {\n cmp = MathUtil.compareNumbers(this._minute, other._minute);\n if (cmp === 0) {\n cmp = MathUtil.compareNumbers(this._second, other._second);\n if (cmp === 0) {\n cmp = MathUtil.compareNumbers(this._nano, other._nano);\n }\n }\n }\n return cmp;\n }\n\n /**\n * Checks if this {@code LocalTime} is after the specified time.\n * \n * The comparison is based on the time-line position of the time within a day.\n *\n * @param other the other time to compare to, not null\n * @return true if this is after the specified time\n * @throws NullPointerException if {@code other} is null\n */\n isAfter(other) {\n return this.compareTo(other) > 0;\n }\n\n /**\n * Checks if this {@code LocalTime} is before the specified time.\n * \n * The comparison is based on the time-line position of the time within a day.\n *\n * @param other the other time to compare to, not null\n * @return true if this point is before the specified time\n * @throws NullPointerException if {@code other} is null\n */\n isBefore(other) {\n return this.compareTo(other) < 0;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Checks if this time is equal to another time.\n * \n * The comparison is based on the time-line position of the time within a day.\n * \n * Only objects of type {@code LocalTime} are compared, other types return false.\n * To compare the date of two {@code TemporalAccessor} instances, use\n * {@link ChronoField#NANO_OF_DAY} as a comparator.\n *\n * @param other the object to check, null returns false\n * @return true if this is equal to the other time\n */\n equals(other) {\n if (this === other) {\n return true;\n }\n if (other instanceof LocalTime) {\n return this._hour === other._hour && this._minute === other._minute &&\n this._second === other._second && this._nano === other._nano;\n }\n return false;\n }\n\n /**\n * A hash code for this time.\n *\n * @return a suitable hash code\n */\n hashCode() {\n var nod = this.toNanoOfDay();\n return (nod ^ (nod >>> 24));\n }\n\n //-----------------------------------------------------------------------\n /**\n * Outputs this time as a {@code String}, such as {@code 10:15}.\n * \n * The output will be one of the following ISO-8601 formats:\n * \n * The format used will be the shortest that outputs the full value of\n * the time where the omitted parts are implied to be zero.\n *\n * @return a string representation of this time, not null\n */\n toString() {\n var buf = '';\n var hourValue = this._hour;\n var minuteValue = this._minute;\n var secondValue = this._second;\n var nanoValue = this._nano;\n buf += hourValue < 10 ? '0' : '';\n buf += hourValue;\n buf += minuteValue < 10 ? ':0' : ':';\n buf += minuteValue;\n if (secondValue > 0 || nanoValue > 0) {\n buf += secondValue < 10 ? ':0' : ':';\n buf += secondValue;\n if (nanoValue > 0) {\n buf += '.';\n if(MathUtil.intMod(nanoValue, 1000000) === 0) {\n buf += ('' + (MathUtil.intDiv(nanoValue, 1000000) + 1000)).substring(1);\n } else if (MathUtil.intMod(nanoValue, 1000) === 0) {\n buf += ('' + (MathUtil.intDiv(nanoValue, 1000) + 1000000)).substring(1);\n } else {\n buf += ('' + (nanoValue + 1000000000)).substring(1);\n }\n }\n }\n return buf;\n }\n\n /**\n * Outputs this time as a {@code String} using the formatter.\n * \n * This time will be passed to the formatter\n * {@link DateTimeFormatter#format(TemporalAccessor) print method}.\n *\n * @param formatter the formatter to use, not null\n * @return the formatted time string, not null\n * @throws DateTimeException if an error occurs during printing\n */\n format(formatter) {\n requireNonNull(formatter, 'formatter');\n return formatter.format(this);\n }\n}\n\nexport function _init() {\n /**\n * Constants for the local time of each hour.\n */\n LocalTime.HOURS = [];\n for (let i = 0; i < 24; i++) {\n LocalTime.HOURS[i] = makeLocalTimeConst(i);\n }\n\n function makeLocalTimeConst(hour = 0, minute = 0, second = 0, nano = 0) {\n var localTime = Object.create(LocalTime.prototype);\n TemporalAccessor.call(localTime);\n localTime._hour = hour;\n localTime._minute = minute;\n localTime._second = second;\n localTime._nano = nano;\n return localTime;\n }\n\n /**\n * The minimum supported {@code LocalTime}, '00:00'.\n * This is the time of midnight at the start of the day.\n */\n LocalTime.MIN = LocalTime.HOURS[0];\n /**\n * The maximum supported {@code LocalTime}, '23:59:59.999999999'.\n * This is the time just before midnight at the end of the day.\n */\n LocalTime.MAX = makeLocalTimeConst(23, 59, 59, 999999999);\n /**\n * The time of midnight at the start of the day, '00:00'.\n */\n LocalTime.MIDNIGHT = LocalTime.HOURS[0];\n /**\n * The time of noon in the middle of the day, '12:00'.\n */\n LocalTime.NOON = LocalTime.HOURS[12];\n\n var FROM;\n LocalTime.FROM = () => {\n return FROM || (FROM = createTemporalQuery('LocalTime.FROM', (temporal) => {\n return LocalTime.from(temporal);\n }));\n };\n\n /**\n * Hours per day.\n */\n LocalTime.HOURS_PER_DAY = 24;\n /**\n * Minutes per hour.\n */\n LocalTime.MINUTES_PER_HOUR = 60;\n /**\n * Minutes per day.\n */\n LocalTime.MINUTES_PER_DAY = LocalTime.MINUTES_PER_HOUR * LocalTime.HOURS_PER_DAY;\n /**\n * Seconds per minute.\n */\n LocalTime.SECONDS_PER_MINUTE = 60;\n /**\n * Seconds per hour.\n */\n LocalTime.SECONDS_PER_HOUR = LocalTime.SECONDS_PER_MINUTE * LocalTime.MINUTES_PER_HOUR;\n /**\n * Seconds per day.\n */\n LocalTime.SECONDS_PER_DAY = LocalTime.SECONDS_PER_HOUR * LocalTime.HOURS_PER_DAY;\n /**\n * Milliseconds per day.\n */\n LocalTime.MILLIS_PER_DAY = LocalTime.SECONDS_PER_DAY * 1000;\n /**\n * Microseconds per day.\n */\n LocalTime.MICROS_PER_DAY = LocalTime.SECONDS_PER_DAY * 1000000;\n /**\n * Nanos per second.\n */\n LocalTime.NANOS_PER_SECOND = 1000000000;\n /**\n * Nanos per minute.\n */\n LocalTime.NANOS_PER_MINUTE = LocalTime.NANOS_PER_SECOND * LocalTime.SECONDS_PER_MINUTE;\n /**\n * Nanos per hour.\n */\n LocalTime.NANOS_PER_HOUR = LocalTime.NANOS_PER_MINUTE * LocalTime.MINUTES_PER_HOUR;\n /**\n * Nanos per day.\n */\n LocalTime.NANOS_PER_DAY = LocalTime.NANOS_PER_HOUR * LocalTime.HOURS_PER_DAY;\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/LocalTime.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport {assert} from '../assert';\n\nimport {DateTimeParseException, NullPointerException} from '../errors';\n\nimport {ParsePosition} from './ParsePosition';\nimport {DateTimeParseContext} from './DateTimeParseContext';\nimport {DateTimeFormatterBuilder} from './DateTimeFormatterBuilder';\nimport {SignStyle} from './SignStyle';\nimport {ResolverStyle} from './ResolverStyle';\n\nimport {IsoChronology} from '../chrono/IsoChronology';\nimport {ChronoField} from '../temporal/ChronoField';\n\nexport class DateTimeFormatter {\n\n //-----------------------------------------------------------------------\n /**\n * Constructor.\n *\n * @param printerParser the printer/parser to use, not null\n * @param locale the locale to use, not null\n * @param decimalStyle the decimal style to use, not null\n * @param resolverStyle the resolver style to use, not null\n * @param resolverFields the fields to use during resolving, null for all fields\n * @param chrono the chronology to use, null for no override\n * @param zone the zone to use, null for no override\n */\n constructor(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone) {\n assert(printerParser != null);\n assert(decimalStyle != null);\n assert(resolverStyle != null);\n /**\n * The printer and/or parser to use, not null.\n */\n this._printerParser = printerParser;\n /**\n * The locale to use for formatting. // nyi\n */\n this._locale = locale;\n /**\n * The symbols to use for formatting, not null.\n */\n this._decimalStyle = decimalStyle;\n /**\n * The resolver style to use, not null.\n */\n this._resolverStyle = resolverStyle;\n /**\n * The fields to use in resolving, null for all fields.\n */\n this._resolverFields = resolverFields;\n /**\n * The chronology to use for formatting, null for no override.\n */\n this._chrono = chrono;\n /**\n * The zone to use for formatting, null for no override. // nyi\n */\n this._zone = zone;\n }\n\n locale() {\n return this._locale;\n }\n\n decimalStyle() {\n return this._decimalStyle;\n }\n\n chronology() {\n return this._chrono;\n }\n\n /**\n * Returns a copy of this formatter with a new override chronology.\n *\n * This returns a formatter with similar state to this formatter but\n * with the override chronology set.\n * By default, a formatter has no override chronology, returning null.\n *\n * If an override is added, then any date that is printed or parsed will be affected.\n *\n * When printing, if the {@code Temporal} object contains a date then it will\n * be converted to a date in the override chronology.\n * Any time or zone will be retained unless overridden.\n * The converted result will behave in a manner equivalent to an implementation\n * of {@code ChronoLocalDate},{@code ChronoLocalDateTime} or {@code ChronoZonedDateTime}.\n *\n * When parsing, the override chronology will be used to interpret the\n * {@linkplain ChronoField fields} into a date unless the\n * formatter directly parses a valid chronology.\n *\n * This instance is immutable and unaffected by this method call.\n *\n * @param chrono the new chronology, not null\n * @return a formatter based on this formatter with the requested override chronology, not null\n */\n withChronology(chrono) {\n if (this._chrono != null && this._chrono.equals(chrono)) {\n return this;\n }\n return new DateTimeFormatter(this._printerParser, this._locale, this._decimalStyle,\n this._resolverStyle, this._resolverFields, chrono, this._zone);\n }\n\n /**\n * not yet supported\n * @returns {DateTimeFormatter}\n */\n withLocal(){\n return this;\n }\n\n /**\n * Fully parses the text producing a temporal object.\n *\n * This parses the entire text producing a temporal object.\n * It is typically more useful to use {@link #parse(CharSequence, TemporalQuery)}.\n * The result of this method is {@code TemporalAccessor} which has been resolved,\n * applying basic validation checks to help ensure a valid date-time.\n *\n * If the parse completes without reading the entire length of the text,\n * or a problem occurs during parsing or merging, then an exception is thrown.\n *\n * @param text the text to parse, not null\n * @param type the type to extract, not null\n * @return the parsed temporal object, not null\n * @throws DateTimeParseException if unable to parse the requested result\n */\n parse(text, type) {\n assert(text != null, 'text', NullPointerException);\n assert(type != null, 'type', NullPointerException);\n try {\n var builder = this._parseToBuilder(text, null).resolve(this._resolverStyle, this._resolverFields);\n return builder.build(type);\n } catch (ex) {\n if(ex instanceof DateTimeParseException){\n throw ex;\n } else {\n throw this._createError(text, ex);\n }\n }\n }\n\n _createError(text, ex) {\n var abbr = '';\n if (text.length > 64) {\n abbr = text.subString(0, 64) + '...';\n } else {\n abbr = text;\n }\n return new DateTimeParseException('Text \\'' + abbr + '\\' could not be parsed: ' + ex.message, text, 0, ex);\n }\n\n\n /**\n * Parses the text to a builder.\n * \n * This parses to a {@code DateTimeBuilder} ensuring that the text is fully parsed.\n * This method throws {@link DateTimeParseException} if unable to parse, or\n * some other {@code DateTimeException} if another date/time problem occurs.\n *\n * @param text the text to parse, not null\n * @param position the position to parse from, updated with length parsed\n * and the index of any error, null if parsing whole string\n * @return the engine representing the result of the parse, not null\n * @throws DateTimeParseException if the parse fails\n */\n _parseToBuilder(text, position) {\n var pos = (position != null ? position : new ParsePosition(0));\n var result = this._parseUnresolved0(text, pos);\n if (result == null || pos.getErrorIndex() >= 0 || (position == null && pos.getIndex() < text.length)) {\n var abbr = '';\n if (text.length > 64) {\n abbr = text.substr(0, 64).toString() + '...';\n } else {\n abbr = text;\n }\n if (pos.getErrorIndex() >= 0) {\n throw new DateTimeParseException('Text \\'' + abbr + '\\' could not be parsed at index ' +\n pos.getErrorIndex(), text, pos.getErrorIndex());\n } else {\n throw new DateTimeParseException('Text \\'' + abbr + '\\' could not be parsed, unparsed text found at index ' +\n pos.getIndex(), text, pos.getIndex());\n }\n }\n return result.toBuilder();\n }\n\n /**\n * Parses the text using this formatter, without resolving the result, intended\n * for advanced use cases.\n * \n * Parsing is implemented as a two-phase operation.\n * First, the text is parsed using the layout defined by the formatter, producing\n * a {@code Map} of field to value, a {@code ZoneId} and a {@code Chronology}.\n * Second, the parsed data is resolved, by validating, combining and\n * simplifying the various fields into more useful ones.\n * This method performs the parsing stage but not the resolving stage.\n * \n * The result of this method is {@code TemporalAccessor} which represents the\n * data as seen in the input. Values are not validated, thus parsing a date string\n * of '2012-00-65' would result in a temporal with three fields - year of '2012',\n * month of '0' and day-of-month of '65'.\n * \n * The text will be parsed from the specified start {@code ParsePosition}.\n * The entire length of the text does not have to be parsed, the {@code ParsePosition}\n * will be updated with the index at the end of parsing.\n * \n * Errors are returned using the error index field of the {@code ParsePosition}\n * instead of {@code DateTimeParseException}.\n * The returned error index will be set to an index indicative of the error.\n * Callers must check for errors before using the context.\n * \n * If the formatter parses the same field more than once with different values,\n * the result will be an error.\n * \n * This method is intended for advanced use cases that need access to the\n * internal state during parsing. Typical application code should use\n * {@link #parse(CharSequence, TemporalQuery)} or the parse method on the target type.\n *\n * @param text the text to parse, not null\n * @param position the position to parse from, updated with length parsed\n * and the index of any error, not null\n * @return the parsed text, null if the parse results in an error\n * @throws DateTimeException if some problem occurs during parsing\n * @throws IndexOutOfBoundsException if the position is invalid\n */\n parseUnresolved(text, position) {\n return this._parseUnresolved0(text, position);\n }\n\n _parseUnresolved0(text, position) {\n assert(text != null, 'text', NullPointerException);\n assert(position != null, 'position', NullPointerException);\n var context = new DateTimeParseContext(this);\n var pos = position.getIndex();\n pos = this._printerParser.parse(context, text, pos);\n if (pos < 0) {\n position.setErrorIndex(~pos); // index not updated from input\n return null;\n }\n position.setIndex(pos); // errorIndex not updated from input\n return context.toParsed();\n }\n\n\n toString() {\n var pattern = this._printerParser.toString();\n return pattern.indexOf('[') === 0 ? pattern : pattern.substring(1, pattern.length - 1);\n }\n\n}\n\nexport function _init() {\n DateTimeFormatter.ISO_LOCAL_DATE = new DateTimeFormatterBuilder()\n .appendValue(ChronoField.YEAR, 4, 10, SignStyle.EXCEEDS_PAD)\n .appendLiteral('-')\n .appendValue(ChronoField.MONTH_OF_YEAR, 2)\n .appendLiteral('-')\n .appendValue(ChronoField.DAY_OF_MONTH, 2)\n .toFormatter(ResolverStyle.STRICT).withChronology(IsoChronology.INSTANCE);\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/format/DateTimeFormatter.js\n **/","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nexport class ParsePosition {\n constructor(index) {\n this._index = index;\n this._errorIndex = -1;\n }\n\n getIndex(){\n return this._index;\n }\n\n setIndex(index){\n this._index = index;\n }\n\n getErrorIndex(){\n return this._errorIndex;\n }\n\n setErrorIndex(errorIndex){\n this._errorIndex = errorIndex;\n }\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/format/ParsePosition.js\n **/","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport {assert} from '../assert';\n\nimport {DateTimeBuilder} from './DateTimeBuilder';\nimport {EnumMap} from './EnumMap';\n\nimport {IsoChronology} from '../chrono/IsoChronology';\nimport {TemporalAccessor} from '../temporal/TemporalAccessor';\nimport {TemporalQueries} from '../temporal/TemporalQueries';\n\nexport class DateTimeParseContext{\n\n constructor(){\n if(arguments.length === 1){\n this._constructorFormatter.apply(this, arguments);\n } else {\n this._constructorParam.apply(this, arguments);\n }\n\n this._caseSensitive = true;\n this._strict = true;\n this._parsed = [new Parsed(this)];\n }\n\n _constructorParam(locale, symbols, chronology){\n this._locale = locale;\n this._symbols = symbols;\n this._overrideChronology = chronology;\n }\n\n _constructorFormatter(formatter){\n this._locale = formatter.locale();\n this._symbols = formatter.decimalStyle();\n this._overrideChronology = formatter.chronology();\n }\n\n\n symbols(){\n return this._symbols;\n }\n\n isStrict(){\n return this._strict;\n }\n\n setStrict(strict){\n this._strict = strict;\n }\n\n /**\n * Checks if parsing is case sensitive.\n *\n * @return true if parsing is case sensitive, false if case insensitive\n */\n isCaseSensitive() {\n return this._caseSensitive;\n }\n\n /**\n * Sets whether the parsing is case sensitive or not.\n *\n * @param caseSensitive changes the parsing to be case sensitive or not from now on\n */\n setCaseSensitive(caseSensitive) {\n this._caseSensitive = caseSensitive;\n }\n\n /**\n * Helper to compare two {@code CharSequence} instances.\n * This uses {@link #isCaseSensitive()}.\n *\n * @param cs1 the first character sequence, not null\n * @param offset1 the offset into the first sequence, valid\n * @param cs2 the second character sequence, not null\n * @param offset2 the offset into the second sequence, valid\n * @param length the length to check, valid\n * @return true if equal\n */\n subSequenceEquals(cs1, offset1, cs2, offset2, length) {\n if (offset1 + length > cs1.length || offset2 + length > cs2.length) {\n return false;\n }\n if (! this.isCaseSensitive()) {\n cs1 = cs1.toLowerCase();\n cs2 = cs2.toLowerCase();\n }\n for (let i = 0; i < length; i++) {\n let ch1 = cs1[offset1 + i];\n let ch2 = cs2[offset2 + i];\n if (ch1 !== ch2) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Helper to compare two {@code char}.\n * This uses {@link #isCaseSensitive()}.\n *\n * @param ch1 the first character\n * @param ch2 the second character\n * @return true if equal\n */\n charEquals(ch1, ch2) {\n if (this.isCaseSensitive()) {\n return ch1 === ch2;\n }\n return this.charEqualsIgnoreCase(ch1, ch2);\n }\n\n /**\n * Compares two characters ignoring case.\n *\n * @param c1 the first\n * @param c2 the second\n * @return true if equal\n */\n charEqualsIgnoreCase(c1, c2) {\n return c1 === c2 ||\n c1.toLowerCase() === c2.toLowerCase();\n }\n\n setParsedField(field, value, errorPos, successPos){\n var currentParsedFieldValues = this.currentParsed().fieldValues;\n var old = currentParsedFieldValues.get(field);\n currentParsedFieldValues.set(field, value);\n return (old != null && old !== value) ? ~errorPos : successPos;\n }\n\n getParsed(field) {\n return this.currentParsed().fieldValues.get(field);\n }\n\n toParsed() {\n return this.currentParsed();\n }\n\n currentParsed() {\n return this._parsed[this._parsed.length - 1];\n }\n\n /**\n * Gets the effective chronology during parsing.\n *\n * @return the effective parsing chronology, not null\n */\n getEffectiveChronology() {\n var chrono = this.currentParsed().chrono;\n if (chrono == null) {\n chrono = this._overrideChronology;\n if (chrono == null) {\n chrono = IsoChronology.INSTANCE;\n }\n }\n return chrono;\n }\n\n\n}\n\nclass Parsed extends TemporalAccessor {\n constructor(dateTimeParseContext){\n super();\n this.chrono = null;\n this.zone = null;\n this.fieldValues = new EnumMap();\n this.leapSecond = false;\n this.dateTimeParseContext = dateTimeParseContext;\n }\n\n copy() {\n var cloned = new Parsed();\n cloned.chrono = this.chrono;\n cloned.zone = this.zone;\n cloned.fieldValues.putAll(this.fieldValues);\n cloned.leapSecond = this.leapSecond;\n return cloned;\n }\n\n toString() {\n return `${this.fieldValues}, ${this.chrono}, ${this.zone}`;\n }\n\n isSupported(field) {\n return this.fieldValues.containsKey(field);\n }\n\n get(field) {\n var val = this.fieldValues.get(field);\n assert(val != null);\n return val;\n }\n\n query(query) {\n if (query === TemporalQueries.chronology()) {\n return this.chrono;\n }\n if (query === TemporalQueries.zoneId() || query === TemporalQueries.zone()) {\n return this.zone;\n }\n return super.query(query);\n }\n\n toBuilder() {\n var builder = new DateTimeBuilder();\n builder.fieldValues.putAll(this.fieldValues);\n builder.chrono = this.dateTimeParseContext.getEffectiveChronology();\n if (this.zone != null) {\n builder.zone = this.zone;\n } else {\n builder.zone = this.overrideZone;\n }\n builder.leapSecond = this.leapSecond;\n builder.excessDays = this.excessDays;\n return builder;\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/format/DateTimeParseContext.js\n **/","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport {DateTimeException} from '../errors';\n\nimport {EnumMap} from './EnumMap';\nimport {IsoChronology} from '../chrono/IsoChronology';\nimport {ChronoLocalDate} from '../chrono/ChronoLocalDate';\nimport {ChronoField} from '../temporal/ChronoField';\nimport {TemporalAccessor} from '../temporal/TemporalAccessor';\nimport {TemporalQueries} from '../temporal/TemporalQueries';\n\nimport {LocalTime} from '../LocalTime';\nimport {LocalDate} from '../LocalDate';\n\n//import {ZoneOffset} from '../ZoneOffset';\n\n/**\n * Builder that can holds date and time fields and related date and time objects.\n * \n * The builder is used to hold onto different elements of date and time.\n * It is designed as two separate maps:\n * \n *\n * \n * This examines the contents of the builder and resolves it to produce the best\n * available date and time, throwing an exception if a problem occurs.\n * Calling this method changes the state of the builder.\n *\n * @param resolverStyle how to resolve\n * @param resolverFields\n * @return {@code this}, for method chaining\n */\n resolve(resolverStyle, resolverFields) {\n if (resolverFields != null) {\n this.fieldValues.retainAll(resolverFields);\n }\n // handle standard fields\n // this._mergeInstantFields();\n this._mergeDate(resolverStyle);\n //mergeTime(resolverStyle);\n //if (resolveFields(resolverStyle)) {\n // mergeInstantFields();\n // mergeDate(resolverStyle);\n // mergeTime(resolverStyle);\n //}\n //resolveTimeInferZeroes(resolverStyle);\n //crossCheck();\n //if (excessDays != null && excessDays.isZero() == false && date != null && time != null) {\n // date = date.plus(excessDays);\n // excessDays = Period.ZERO;\n //}\n //resolveFractional();\n //resolveInstant();\n return this;\n }\n\n _mergeDate(resolverStyle) {\n //if (this.chrono instanceof IsoChronology) {\n this._checkDate(IsoChronology.INSTANCE.resolveDate(this.fieldValues, resolverStyle));\n //} else {\n // if (this.fieldValues.containsKey(ChronoField.EPOCH_DAY)) {\n // this._checkDate(LocalDate.ofEpochDay(this.fieldValues.remove(ChronoField.EPOCH_DAY)));\n // return;\n // }\n //}\n }\n\n _checkDate(date) {\n if (date != null) {\n this._addObject(date);\n for (let field in this.fieldValues.keySet()) {\n if (field instanceof ChronoField) {\n if (field.isDateBased()) {\n var val1;\n try {\n val1 = date.getLong(field);\n } catch (ex) {\n if(ex instanceof DateTimeException){\n continue;\n } else {\n throw ex;\n }\n }\n var val2 = this.fieldValues.get(field);\n if (val1 !== val2) {\n throw new DateTimeException('Conflict found: Field ' + field + ' ' + val1 + ' differs from ' + field + ' ' + val2 + ' derived from ' + date);\n }\n }\n }\n }\n }\n }\n\n _addObject(dateOrTime) {\n if (dateOrTime instanceof ChronoLocalDate){\n this.date = dateOrTime;\n } else if (dateOrTime instanceof LocalTime){\n this.time = dateOrTime;\n }\n }\n\n /**\n * Builds the specified type from the values in this builder.\n *\n * This attempts to build the specified type from this builder.\n * If the builder cannot return the type, an exception is thrown.\n *\n * @param type the type to invoke {@code from} on, not null\n * @return the extracted value, not null\n * @throws DateTimeException if an error occurs\n */\n build(type) {\n return type.queryFrom(this);\n }\n\n query(query) {\n if (query === TemporalQueries.zoneId()) {\n return this.zone;\n } else if (query === TemporalQueries.chronology()) {\n return this.chrono;\n } else if (query === TemporalQueries.localDate()) {\n return this.date != null ? LocalDate.from(this.date) : null;\n } else if (query === TemporalQueries.localTime()) {\n return this.time;\n } else if (query === TemporalQueries.zone() || query === TemporalQueries.offset()) {\n return query.queryFrom(this);\n } else if (query === TemporalQueries.precision()) {\n return null; // not a complete date/time\n }\n // inline TemporalAccessor.super.query(query) as an optimization\n // non-JDK classes are not permitted to make this optimization\n return query.queryFrom(this);\n }\n\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/format/DateTimeBuilder.js\n **/","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nexport class EnumMap {\n constructor(){\n this._map = {};\n }\n\n putAll(otherMap){\n for(let key in otherMap._map){\n this._map[key] = otherMap._map[key];\n }\n return this;\n }\n\n containsKey(key){\n return this._map.hasOwnProperty(key.name());\n }\n\n get(key) {\n return this._map[key.name()];\n }\n\n set(key, val) {\n this._map[key.name()] = val;\n return this;\n }\n\n retainAll(keyList){\n var map = {};\n for(let i=0; i \n * This returns a {@code LocalDate} with the specified year, month and day-of-month.\n * The day must be valid for the year and month, otherwise an exception will be thrown.\n *\n * @param {number} year the year to represent, from MIN_YEAR to MAX_YEAR\n * @param {Month, number} month the month-of-year to represent, from 1 (January) to 12 (December)\n * @param {number} dayOfMonth the day-of-month to represent, from 1 to 31\n * @return LocalDate the local date, not null\n * @throws DateTimeException if the value of any field is out of range,\n * or if the day-of-month is invalid for the month-year\n */\n static of(year, month, dayOfMonth) {\n return new LocalDate(year, month, dayOfMonth);\n }\n\n /**\n * Obtains an instance of {@code LocalDate} from a year and day-of-year.\n * \n * This returns a {@code LocalDate} with the specified year and day-of-year.\n * The day-of-year must be valid for the year, otherwise an exception will be thrown.\n *\n * @param {number} year the year to represent, from MIN_YEAR to MAX_YEAR\n * @param {number} dayOfYear the day-of-year to represent, from 1 to 366\n * @return LocalDate the local date, not null\n * @throws DateTimeException if the value of any field is out of range,\n * or if the day-of-year is invalid for the year\n */\n static ofYearDay(year, dayOfYear) {\n ChronoField.YEAR.checkValidValue(year);\n //TODO: ChronoField.DAY_OF_YEAR.checkValidValue(dayOfYear);\n var leap = IsoChronology.isLeapYear(year);\n if (dayOfYear === 366 && leap === false) {\n assert(false, 'Invalid date \\'DayOfYear 366\\' as \\'' + year + '\\' is not a leap year', DateTimeException);\n }\n var moy = Month.of(Math.floor((dayOfYear - 1) / 31 + 1));\n var monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;\n if (dayOfYear > monthEnd) {\n moy = moy.plus(1);\n }\n var dom = dayOfYear - moy.firstDayOfYear(leap) + 1;\n return new LocalDate(year, moy.value(), dom);\n }\n\n /**\n * Obtains an instance of LocalDate from the epoch day count.\n *\n * This returns a LocalDate with the specified epoch-day.\n * The {@link ChronoField#EPOCH_DAY EPOCH_DAY} is a simple incrementing count\n * of days where day 0 is 1970-01-01. Negative numbers represent earlier days.\n *\n * @param {number} epochDay - the Epoch Day to convert, based on the epoch 1970-01-01\n * @return {LocalDate} the local date, not null\n * @throws AssertionError if the epoch days exceeds the supported date range\n */\n static ofEpochDay(epochDay) {\n var adjust, adjustCycles, dom, doyEst, marchDoy0, marchMonth0, month, year, yearEst, zeroDay;\n zeroDay = epochDay + DAYS_0000_TO_1970;\n zeroDay -= 60;\n adjust = 0;\n if (zeroDay < 0) {\n adjustCycles = MathUtil.intDiv(zeroDay + 1, DAYS_PER_CYCLE) - 1;\n adjust = adjustCycles * 400;\n zeroDay += -adjustCycles * DAYS_PER_CYCLE;\n }\n yearEst = MathUtil.intDiv(400 * zeroDay + 591, DAYS_PER_CYCLE);\n doyEst = zeroDay - (365 * yearEst + MathUtil.intDiv(yearEst, 4) - MathUtil.intDiv(yearEst, 100) + MathUtil.intDiv(yearEst, 400));\n if (doyEst < 0) {\n yearEst--;\n doyEst = zeroDay - (365 * yearEst + MathUtil.intDiv(yearEst, 4) - MathUtil.intDiv(yearEst, 100) + MathUtil.intDiv(yearEst, 400));\n }\n yearEst += adjust;\n marchDoy0 = doyEst;\n marchMonth0 = MathUtil.intDiv(marchDoy0 * 5 + 2, 153);\n month = (marchMonth0 + 2) % 12 + 1;\n dom = marchDoy0 - MathUtil.intDiv(marchMonth0 * 306 + 5, 10) + 1;\n yearEst += MathUtil.intDiv(marchMonth0, 10);\n year = yearEst;\n return new LocalDate(year, month, dom);\n }\n\n /**\n * Obtains an instance of {@code LocalDate} from a temporal object.\n * \n * A {@code TemporalAccessor} represents some form of date and time information.\n * This factory converts the arbitrary temporal object to an instance of {@code LocalDate}.\n * \n * The conversion uses the {@link TemporalQueries#localDate()} query, which relies\n * on extracting the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field.\n * \n * This method matches the signature of the functional interface {@link TemporalQuery}\n * allowing it to be used as a query via method reference, {@code LocalDate::from}.\n *\n * @param temporal the temporal object to convert, not null\n * @return the local date, not null\n * @throws DateTimeException if unable to convert to a {@code LocalDate}\n */\n static from(temporal) {\n assert(temporal != null, '', NullPointerException);\n var date = temporal.query(TemporalQueries.localDate());\n if (date == null) {\n throw new DateTimeException(\n `Unable to obtain LocalDate from TemporalAccessor: ${temporal}, type ${temporal.constructor != null ? temporal.constructor.name : ''}`);\n }\n return date;\n }\n\n /**\n * Obtains an instance of {@code LocalDate} from a text string using a specific formatter.\n *\n * The text is parsed using the formatter, returning a date.\n *\n * @param text the text to parse, not null\n * @param formatter the formatter to use, default is DateTimeFormatter.ISO_LOCAL_DATE\n * @return the parsed local date, not null\n * @throws DateTimeParseException if the text cannot be parsed\n */\n static parse(text, formatter = DateTimeFormatter.ISO_LOCAL_DATE){\n assert(formatter != null, 'formatter', NullPointerException);\n return formatter.parse(text, LocalDate.FROM);\n }\n\n /**\n * Resolves the date, resolving days past the end of month.\n *\n * @param year the year to represent, validated from MIN_YEAR to MAX_YEAR\n * @param month the month-of-year to represent, validated from 1 to 12\n * @param day the day-of-month to represent, validated from 1 to 31\n * @return LocalDate resolved date, not null\n */\n static _resolvePreviousValid(year, month, day) {\n switch (month) {\n case 2:\n day = Math.min(day, IsoChronology.isLeapYear(year) ? 29 : 28);\n break;\n case 4:\n case 6:\n case 9:\n case 11:\n day = Math.min(day, 30);\n break;\n }\n return LocalDate.of(year, month, day);\n }\n\n /**\n *\n * @param {number} year\n * @param {Month, number} month\n * @param {number} dayOfMonth\n */\n constructor(year, month, dayOfMonth){\n super();\n if (month instanceof Month) {\n month = month.value();\n }\n LocalDate._validate(year, month, dayOfMonth);\n this._year = year;\n this._month = month;\n this._day = dayOfMonth;\n }\n\n /**\n * @private\n */\n static _validate(year, month, dayOfMonth) {\n var dom;\n ChronoField.YEAR.checkValidValue(year);\n ChronoField.MONTH_OF_YEAR.checkValidValue(month);\n ChronoField.DAY_OF_MONTH.checkValidValue(dayOfMonth);\n if (dayOfMonth > 28) {\n dom = 31;\n switch (month) {\n case 2:\n dom = IsoChronology.isLeapYear(year) ? 29 : 28;\n break;\n case 4:\n case 6:\n case 9:\n case 11:\n dom = 30;\n }\n if (dayOfMonth > dom) {\n if (dayOfMonth === 29) {\n assert(false, 'Invalid date \\'February 29\\' as \\'' + year + '\\' is not a leap year', DateTimeException);\n } else {\n assert(false, 'Invalid date \\'' + year + '\\' \\'' + month + '\\' \\'' + dayOfMonth + '\\'', DateTimeException);\n }\n }\n }\n }\n\n /**\n * Checks if the specified field is supported.\n * \n * This checks if this date can be queried for the specified field.\n * If false, then calling the {@link #range(TemporalField) range} and\n * {@link #get(TemporalField) get} methods will throw an exception.\n * \n * If the field is a {@link ChronoField} then the query is implemented here.\n * The {@link #isSupported(TemporalField) supported fields} will return valid\n * values based on this date-time.\n * The supported fields are:\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}\n * passing {@code this} as the argument.\n * Whether the field is supported is determined by the field.\n *\n * @param field the field to check, null returns false\n * @return true if the field is supported on this date, false if not\n */\n isSupported(field) {\n return super.isSupported(field);\n }\n\n get(field) {\n return this.getLong(field);\n }\n\n getLong(field) {\n assert(field != null, '', NullPointerException);\n if (field instanceof ChronoField) {\n return this._get0(field);\n }\n return field.getFrom(this);\n }\n\n _get0(field) {\n switch (field) {\n case ChronoField.DAY_OF_WEEK: return this.dayOfWeek().value();\n case ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH: return ((this._day - 1) % 7) + 1;\n case ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR: return ((this.dayOfYear() - 1) % 7) + 1;\n case ChronoField.DAY_OF_MONTH: return this._day;\n case ChronoField.DAY_OF_YEAR: return this.dayOfYear();\n case ChronoField.EPOCH_DAY: return this.toEpochDay();\n case ChronoField.ALIGNED_WEEK_OF_MONTH: return ((this._day - 1) / 7) + 1;\n case ChronoField.ALIGNED_WEEK_OF_YEAR: return ((this.dayOfYear() - 1) / 7) + 1;\n case ChronoField.MONTH_OF_YEAR: return this._month;\n case ChronoField.PROLEPTIC_MONTH: return this._prolepticMonth();\n case ChronoField.YEAR_OF_ERA: return (this._year >= 1 ? this._year : 1 - this._year);\n case ChronoField.YEAR: return this._year;\n case ChronoField.ERA: return (this._year >= 1 ? 1 : 0);\n }\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n\n _prolepticMonth() {\n return (this._year * 12) + (this._month - 1);\n }\n\n /**\n * Gets the chronology of this date, which is the ISO calendar system.\n * \n * The {@code Chronology} represents the calendar system in use.\n * The ISO-8601 calendar system is the modern civil calendar system used today\n * in most of the world. It is equivalent to the proleptic Gregorian calendar\n * system, in which todays's rules for leap years are applied for all time.\n *\n * @return the ISO chronology, not null\n */\n chronology() {\n return IsoChronology.INSTANCE;\n }\n\n /**\n *\n * @return {number} gets the year\n */\n year() {\n return this._year;\n }\n\n /**\n *\n * @return {number} gets the month\n */\n monthValue() {\n return this._month;\n }\n \n month() {\n return Month.of(this._month);\n }\n\n /**\n *\n * @return {number} gets the day of month\n */\n dayOfMonth() {\n return this._day;\n }\n\n /**\n * Gets the day-of-year field.\n * \n * This method returns the primitive {@code int} value for the day-of-year.\n *\n * @return the day-of-year, from 1 to 365, or 366 in a leap year\n */\n dayOfYear() {\n return this.month().firstDayOfYear(this.isLeapYear()) + this._day - 1;\n }\n\n /**\n * Gets the day-of-week field, which is an enum {@code DayOfWeek}.\n * \n * This method returns the enum {@link DayOfWeek} for the day-of-week.\n * This avoids confusion as to what {@code int} values mean.\n * If you need access to the primitive {@code int} value then the enum\n * provides the {@link DayOfWeek#getValue() int value}.\n * \n * Additional information can be obtained from the {@code DayOfWeek}.\n * This includes textual names of the values.\n *\n * @return the day-of-week, not null\n */\n dayOfWeek() {\n var dow0 = MathUtil.floorMod(this.toEpochDay() + 3, 7);\n return DayOfWeek.of(dow0 + 1);\n }\n\n /**\n * Checks if the year is a leap year, according to the ISO proleptic\n * calendar system rules.\n * \n * This method applies the current rules for leap years across the whole time-line.\n * In general, a year is a leap year if it is divisible by four without\n * remainder. However, years divisible by 100, are not leap years, with\n * the exception of years divisible by 400 which are.\n * \n * For example, 1904 is a leap year it is divisible by 4.\n * 1900 was not a leap year as it is divisible by 100, however 2000 was a\n * leap year as it is divisible by 400.\n * \n * The calculation is proleptic - applying the same rules into the far future and far past.\n * This is historically inaccurate, but is correct for the ISO-8601 standard.\n *\n * @return true if the year is leap, false otherwise\n */\n isLeapYear() {\n return IsoChronology.isLeapYear(this._year);\n }\n\n /**\n * Returns the length of the month represented by this date.\n * \n * This returns the length of the month in days.\n * For example, a date in January would return 31.\n *\n * @return the length of the month in days\n */\n lengthOfMonth() {\n switch (this._month) {\n case 2:\n return (this.isLeapYear() ? 29 : 28);\n case 4:\n case 6:\n case 9:\n case 11:\n return 30;\n default:\n return 31;\n }\n }\n\n /**\n * Returns the length of the year represented by this date.\n * \n * This returns the length of the year in days, either 365 or 366.\n *\n * @return 366 if the year is leap, 365 otherwise\n */\n lengthOfYear() {\n return (this.isLeapYear() ? 366 : 365);\n }\n\n /**\n * function overloading for the with method.\n *\n * calling \"with\" with one (or less) argument, assumes that the argument is an TemporalAdjuster,\n * otherwise a field and newValue argument is expected.\n *\n * @param fieldOrAdjuster\n * @param newValue\n */\n with(fieldOrAdjuster, newValue){\n if(arguments.length < 2){\n return this._withTemporalAdjuster(fieldOrAdjuster);\n } else {\n return this._with2(fieldOrAdjuster, newValue);\n }\n }\n\n /**\n * Returns an adjusted copy of this date.\n * \n * This returns a new {@code LocalDate}, based on this one, with the date adjusted.\n * The adjustment takes place using the specified adjuster strategy object.\n * Read the documentation of the adjuster to understand what adjustment will be made.\n * \n * A simple adjuster might simply set the one of the fields, such as the year field.\n * A more complex adjuster might set the date to the last day of the month.\n * A selection of common adjustments is provided in {@link TemporalAdjusters}.\n * These include finding the \"last day of the month\" and \"next Wednesday\".\n * Key date-time classes also implement the {@code TemporalAdjuster} interface,\n * such as {@link Month} and {@link MonthDay}.\n * The adjuster is responsible for handling special cases, such as the varying\n * lengths of month and leap years.\n * \n * For example this code returns a date on the last day of July:\n * \n * The result of this method is obtained by invoking the\n * {@link TemporalAdjuster#adjustInto(Temporal)} method on the\n * specified adjuster passing {@code this} as the argument.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param adjuster the adjuster to use, not null\n * @return a {@code LocalDate} based on {@code this} with the adjustment made, not null\n * @throws DateTimeException if the adjustment cannot be made\n * @throws ArithmeticException if numeric overflow occurs\n */\n _withTemporalAdjuster(adjuster) {\n assert(adjuster != null, 'adjuster', NullPointerException);\n assert(typeof adjuster.adjustInto === 'function', adjuster + 'is mot an adjuster', IllegalArgumentException);\n // optimizations\n if (adjuster instanceof LocalDate) {\n return adjuster;\n }\n return adjuster.adjustInto(this);\n }\n\n /**\n * Returns a copy of this date with the specified field set to a new value.\n * \n * This returns a new {@code LocalDate}, based on this one, with the value\n * for the specified field changed.\n * This can be used to change any supported field, such as the year, month or day-of-month.\n * If it is not possible to set the value, because the field is not supported or for\n * some other reason, an exception is thrown.\n * \n * In some cases, changing the specified field can cause the resulting date to become invalid,\n * such as changing the month from 31st January to February would make the day-of-month invalid.\n * In cases like this, the field is responsible for resolving the date. Typically it will choose\n * the previous valid date, which would be the last valid day of February in this example.\n * \n * If the field is a {@link ChronoField} then the adjustment is implemented here.\n * The supported fields behave as follows:\n * \n * In all cases, if the new value is outside the valid range of values for the field\n * then a {@code DateTimeException} will be thrown.\n * \n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.adjustInto(Temporal, long)}\n * passing {@code this} as the argument. In this case, the field determines\n * whether and how to adjust the instant.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param field the field to set in the result, not null\n * @param newValue the new value of the field in the result\n * @return a {@code LocalDate} based on {@code this} with the specified field set, not null\n * @throws DateTimeException if the field cannot be set\n * @throws ArithmeticException if numeric overflow occurs\n */\n _with2(field, newValue) {\n assert(field != null, 'field', NullPointerException);\n if (field instanceof ChronoField) {\n var f = field;\n f.checkValidValue(newValue);\n switch (f) {\n case ChronoField.DAY_OF_WEEK: return this.plusDays(newValue - this.getDayOfWeek().value());\n case ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH: return this.plusDays(newValue - this.getLong(ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH));\n case ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR: return this.plusDays(newValue - this.getLong(ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR));\n case ChronoField.DAY_OF_MONTH: return this.withDayOfMonth(newValue);\n case ChronoField.DAY_OF_YEAR: return this.withDayOfYear(newValue);\n case ChronoField.EPOCH_DAY: return LocalDate.ofEpochDay(newValue);\n case ChronoField.ALIGNED_WEEK_OF_MONTH: return this.plusWeeks(newValue - this.getLong(ChronoField.ALIGNED_WEEK_OF_MONTH));\n case ChronoField.ALIGNED_WEEK_OF_YEAR: return this.plusWeeks(newValue - this.getLong(ChronoField.ALIGNED_WEEK_OF_YEAR));\n case ChronoField.MONTH_OF_YEAR: return this.withMonth(newValue);\n case ChronoField.PROLEPTIC_MONTH: return this.plusMonths(newValue - this.getLong(ChronoField.PROLEPTIC_MONTH));\n case ChronoField.YEAR_OF_ERA: return this.withYear((this._year >= 1 ? newValue : 1 - newValue));\n case ChronoField.YEAR: return this.withYear(newValue);\n case ChronoField.ERA: return (this.getLong(ChronoField.ERA) === newValue ? this : this.withYear(1 - this._year));\n }\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n return field.adjustInto(this, newValue);\n }\n\n /**\n * Returns a copy of this date with the year altered.\n * If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param year the year to set in the result, from MIN_YEAR to MAX_YEAR\n * @return a {@code LocalDate} based on this date with the requested year, not null\n * @throws DateTimeException if the year value is invalid\n */\n withYear(year) {\n if (this._year === year) {\n return this;\n }\n ChronoField.YEAR.checkValidValue(year);\n return LocalDate._resolvePreviousValid(year, this._month, this._day);\n }\n\n /**\n * Returns a copy of this date with the month-of-year altered.\n * If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.\n *\n * This instance is immutable and unaffected by this method call.\n *\n * @param month the month-of-year to set in the result, from 1 (January) to 12 (December)\n * @return a {@code LocalDate} based on this date with the requested month, not null\n * @throws DateTimeException if the month-of-year value is invalid\n */\n withMonth(month) {\n var m = (month instanceof Month) ? month.value() : month;\n if (this._month === m) {\n return this;\n }\n ChronoField.MONTH_OF_YEAR.checkValidValue(m);\n return LocalDate._resolvePreviousValid(this._year, m, this._day);\n }\n\n /**\n * Returns a copy of this {@code LocalDate} with the day-of-month altered.\n * \n * If the resulting date is invalid, an exception is thrown.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {number} dayOfMonth the day-of-month to set in the result, from 1 to 28-31\n * @return {LocalDate} based on this date with the requested day, not null\n * @throws DateTimeException if the day-of-month value is invalid,\n * or if the day-of-month is invalid for the month-year\n */\n withDayOfMonth(dayOfMonth) {\n if (this._day === dayOfMonth) {\n return this;\n }\n return LocalDate.of(this._year, this._month, dayOfMonth);\n }\n\n /**\n * Returns a copy of this date with the day-of-year altered.\n * If the resulting date is invalid, an exception is thrown.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param dayOfYear the day-of-year to set in the result, from 1 to 365-366\n * @return a {@code LocalDate} based on this date with the requested day, not null\n * @throws DateTimeException if the day-of-year value is invalid\n * @throws DateTimeException if the day-of-year is invalid for the year\n */\n withDayOfYear(dayOfYear) {\n if (this.dayOfYear() === dayOfYear) {\n return this;\n }\n return LocalDate.ofYearDay(this._year, dayOfYear);\n }\n\n /**\n * function overloading for plus\n */\n plus(p1, p2){\n if(arguments.length < 2){\n return this._plus1(p1);\n } else {\n return this._plus2(p1, p2);\n }\n }\n\n /**\n * Returns a copy of this date with the specified period added.\n * \n * This method returns a new date based on this date with the specified period added.\n * The amount is typically {@link Period} but may be any other type implementing\n * the {@link TemporalAmount} interface.\n * The calculation is delegated to the specified adjuster, which typically calls\n * back to {@link #plus(long, TemporalUnit)}.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amount the amount to add, not null\n * @return a {@code LocalDate} based on this date with the addition made, not null\n * @throws DateTimeException if the addition cannot be made\n * @throws ArithmeticException if numeric overflow occurs\n */\n _plus1(amount) {\n requireNonNull(amount, 'amount');\n return amount.addTo(this);\n }\n\n /**\n * Returns a copy of this date with the specified period added.\n * \n * This method returns a new date based on this date with the specified period added.\n * This can be used to add any period that is defined by a unit, for example to add years, months or days.\n * The unit is responsible for the details of the calculation, including the resolution\n * of any edge cases in the calculation.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amountToAdd the amount of the unit to add to the result, may be negative\n * @param unit the unit of the period to add, not null\n * @return a {@code LocalDate} based on this date with the specified period added, not null\n * @throws DateTimeException if the unit cannot be added to this type\n */\n _plus2(amountToAdd, unit) {\n requireNonNull(amountToAdd, 'amountToAdd');\n requireNonNull(unit, 'unit');\n if (unit instanceof ChronoUnit) {\n switch (unit) {\n case ChronoUnit.DAYS: return this.plusDays(amountToAdd);\n case ChronoUnit.WEEKS: return this.plusWeeks(amountToAdd);\n case ChronoUnit.MONTHS: return this.plusMonths(amountToAdd);\n case ChronoUnit.YEARS: return this.plusYears(amountToAdd);\n case ChronoUnit.DECADES: return this.plusYears(MathUtil.safeMultiply(amountToAdd, 10));\n case ChronoUnit.CENTURIES: return this.plusYears(MathUtil.safeMultiply(amountToAdd, 100));\n case ChronoUnit.MILLENNIA: return this.plusYears(MathUtil.safeMultiply(amountToAdd, 1000));\n case ChronoUnit.ERAS: return this.with(ChronoField.ERA, MathUtil.safeAdd(this.getLong(ChronoField.ERA), amountToAdd));\n }\n throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);\n }\n return unit.addTo(this, amountToAdd);\n }\n\n /**\n * Returns a copy of this {@code LocalDate} with the specified period in years added.\n * \n * This method adds the specified amount to the years field in three steps:\n * \n * For example, 2008-02-29 (leap year) plus one year would result in the\n * invalid date 2009-02-29 (standard year). Instead of returning an invalid\n * result, the last valid day of the month, 2009-02-28, is selected instead.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param yearsToAdd the years to add, may be negative\n * @return a {@code LocalDate} based on this date with the years added, not null\n * @throws DateTimeException if the result exceeds the supported date range\n */\n plusYears(yearsToAdd) {\n if (yearsToAdd === 0) {\n return this;\n }\n var newYear = ChronoField.YEAR.checkValidIntValue(this._year + yearsToAdd); // safe overflow\n return LocalDate._resolvePreviousValid(newYear, this._month, this._day);\n }\n\n /**\n * Returns a copy of this {@code LocalDate} with the specified period in months added.\n * \n * This method adds the specified amount to the months field in three steps:\n * \n * For example, 2007-03-31 plus one month would result in the invalid date\n * 2007-04-31. Instead of returning an invalid result, the last valid day\n * of the month, 2007-04-30, is selected instead.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param monthsToAdd the months to add, may be negative\n * @return a {@code LocalDate} based on this date with the months added, not null\n * @throws DateTimeException if the result exceeds the supported date range\n */\n plusMonths(monthsToAdd) {\n if (monthsToAdd === 0) {\n return this;\n }\n var monthCount = this._year * 12 + (this._month - 1);\n var calcMonths = monthCount + monthsToAdd; // safe overflow\n var newYear = ChronoField.YEAR.checkValidIntValue(MathUtil.floorDiv(calcMonths, 12));\n var newMonth = MathUtil.floorMod(calcMonths, 12) + 1;\n return LocalDate._resolvePreviousValid(newYear, newMonth, this._day);\n }\n\n /**\n * Returns a copy of this {@code LocalDate} with the specified period in weeks added.\n * \n * This method adds the specified amount in weeks to the days field incrementing\n * the month and year fields as necessary to ensure the result remains valid.\n * The result is only invalid if the maximum/minimum year is exceeded.\n * \n * For example, 2008-12-31 plus one week would result in 2009-01-07.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param weeksToAdd the weeks to add, may be negative\n * @return a {@code LocalDate} based on this date with the weeks added, not null\n * @throws DateTimeException if the result exceeds the supported date range\n */\n plusWeeks(weeksToAdd) {\n return this.plusDays(MathUtil.safeMultiply(weeksToAdd, 7));\n }\n\n\n /**\n * Returns a copy of this LocalDate with the specified number of days added.\n * \n * This method adds the specified amount to the days field incrementing the\n * month and year fields as necessary to ensure the result remains valid.\n * The result is only invalid if the maximum/minimum year is exceeded.\n * \n * For example, 2008-12-31 plus one day would result in 2009-01-01.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {number} daysToAdd - the days to add, may be negative\n * @return {LocalDate} a LocalDate based on this date with the days added, not null\n * @throws AssertionError if the result exceeds the supported date range\n */\n plusDays(daysToAdd) {\n if (daysToAdd === 0) {\n return this;\n }\n var mjDay = MathUtil.safeAdd(this.toEpochDay(), daysToAdd);\n return LocalDate.ofEpochDay(mjDay);\n }\n\n /**\n * function overloading for minus\n */\n minus(p1, p2){\n if(arguments.length < 2){\n return this._minus1(p1);\n } else {\n return this._minus2(p1, p2);\n }\n }\n\n /**\n * Returns a copy of this date with the specified period subtracted.\n * \n * This method returns a new date based on this date with the specified period subtracted.\n * The amount is typically {@link Period} but may be any other type implementing\n * the {@link TemporalAmount} interface.\n * The calculation is delegated to the specified adjuster, which typically calls\n * back to {@link #minus(long, TemporalUnit)}.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amount the amount to subtract, not null\n * @return a {@code LocalDate} based on this date with the subtraction made, not null\n * @throws DateTimeException if the subtraction cannot be made\n * @throws ArithmeticException if numeric overflow occurs\n */\n _minus1(amount) {\n requireNonNull(amount, 'amount');\n return amount.subtractFrom(this);\n }\n\n /**\n * Returns a copy of this date with the specified period subtracted.\n * \n * This method returns a new date based on this date with the specified period subtracted.\n * This can be used to subtract any period that is defined by a unit, for example to subtract years, months or days.\n * The unit is responsible for the details of the calculation, including the resolution\n * of any edge cases in the calculation.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amountToSubtract the amount of the unit to subtract from the result, may be negative\n * @param unit the unit of the period to subtract, not null\n * @return a {@code LocalDate} based on this date with the specified period subtracted, not null\n * @throws DateTimeException if the unit cannot be added to this type\n */\n _minus2(amountToSubtract, unit) {\n requireNonNull(amountToSubtract, 'amountToSubtract');\n requireNonNull(unit, 'unit');\n return this._plus2(-1 * amountToSubtract, unit);\n }\n\n /**\n * Returns a copy of this {@code LocalDate} with the specified period in years subtracted.\n * \n * This method subtracts the specified amount from the years field in three steps:\n * \n * For example, 2008-02-29 (leap year) minus one year would result in the\n * invalid date 2007-02-29 (standard year). Instead of returning an invalid\n * result, the last valid day of the month, 2007-02-28, is selected instead.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param yearsToSubtract the years to subtract, may be negative\n * @return a {@code LocalDate} based on this date with the years subtracted, not null\n * @throws DateTimeException if the result exceeds the supported date range\n */\n minusYears(yearsToSubtract) {\n return this.plusYears(yearsToSubtract * -1);\n }\n\n /**\n * Returns a copy of this {@code LocalDate} with the specified period in months subtracted.\n * \n * This method subtracts the specified amount from the months field in three steps:\n * \n * For example, 2007-03-31 minus one month would result in the invalid date\n * 2007-02-31. Instead of returning an invalid result, the last valid day\n * of the month, 2007-02-28, is selected instead.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param monthsToSubtract the months to subtract, may be negative\n * @return a {@code LocalDate} based on this date with the months subtracted, not null\n * @throws DateTimeException if the result exceeds the supported date range\n */\n minusMonths(monthsToSubtract) {\n return this.plusMonths(monthsToSubtract * -1);\n }\n\n /**\n * Returns a copy of this {@code LocalDate} with the specified period in weeks subtracted.\n * \n * This method subtracts the specified amount in weeks from the days field decrementing\n * the month and year fields as necessary to ensure the result remains valid.\n * The result is only invalid if the maximum/minimum year is exceeded.\n * \n * For example, 2009-01-07 minus one week would result in 2008-12-31.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param weeksToSubtract the weeks to subtract, may be negative\n * @return a {@code LocalDate} based on this date with the weeks subtracted, not null\n * @throws DateTimeException if the result exceeds the supported date range\n */\n minusWeeks(weeksToSubtract) {\n return this.plusWeeks(weeksToSubtract * -1);\n }\n\n /*\n * Returns a copy of this LocalDate with the specified number of days subtracted.\n * \n * This method subtracts the specified amount from the days field decrementing the\n * month and year fields as necessary to ensure the result remains valid.\n * The result is only invalid if the maximum/minimum year is exceeded.\n * \n * For example, 2009-01-01 minus one day would result in 2008-12-31.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {number} daysToSubtract - the days to subtract, may be negative\n * @return {LocalDate} a LocalDate based on this date with the days subtracted, not null\n * @throws AssertionError if the result exceeds the supported date range\n */\n minusDays(daysToSubtract) {\n return this.plusDays(daysToSubtract * -1);\n }\n\n /**\n * Queries this date using the specified query.\n *\n * This queries this date using the specified query strategy object.\n * The {@code TemporalQuery} object defines the logic to be used to\n * obtain the result. Read the documentation of the query to understand\n * what the result of this method will be.\n *\n * The result of this method is obtained by invoking the\n * {@link TemporalQuery#queryFrom(TemporalAccessor)} method on the\n * specified query passing {@code this} as the argument.\n *\n * @param query the query to invoke, not null\n * @return the query result, null may be returned (defined by the query)\n * @throws DateTimeException if unable to query (defined by the query)\n * @throws ArithmeticException if numeric overflow occurs (defined by the query)\n */\n query(query) {\n assert(query != null, '', NullPointerException);\n if (query === TemporalQueries.localDate()) {\n return this;\n }\n return super.query(query);\n }\n\n /**\n * Adjusts the specified temporal object to have the same date as this object.\n * \n * This returns a temporal object of the same observable type as the input\n * with the date changed to be the same as this.\n * \n * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}\n * passing {@link ChronoField#EPOCH_DAY} as the field.\n * \n * In most cases, it is clearer to reverse the calling pattern by using\n * {@link Temporal#with(TemporalAdjuster)}:\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param temporal the target object to be adjusted, not null\n * @return the adjusted object, not null\n * @throws DateTimeException if unable to make the adjustment\n * @throws ArithmeticException if numeric overflow occurs\n */\n adjustInto(temporal) {\n return super.adjustInto(temporal);\n }\n\n /**\n * until function overloading\n */\n until(p1, p2){\n if(arguments.length < 2){\n return this._until1(p1);\n } else {\n return this._until2(p1, p2);\n }\n }\n\n /**\n * Calculates the period between this date and another date in\n * terms of the specified unit.\n * \n * This calculates the period between two dates in terms of a single unit.\n * The start and end points are {@code this} and the specified date.\n * The result will be negative if the end is before the start.\n * The {@code Temporal} passed to this method must be a {@code LocalDate}.\n * For example, the period in days between two dates can be calculated\n * using {@code startDate.until(endDate, DAYS)}.\n * \n * The calculation returns a whole number, representing the number of\n * complete units between the two dates.\n * For example, the period in months between 2012-06-15 and 2012-08-14\n * will only be one month as it is one day short of two months.\n * \n * This method operates in association with {@link TemporalUnit#between}.\n * The result of this method is a {@code long} representing the amount of\n * the specified unit. By contrast, the result of {@code between} is an\n * object that can be used directly in addition/subtraction:\n * \n * The calculation is implemented in this method for {@link ChronoUnit}.\n * The units {@code DAYS}, {@code WEEKS}, {@code MONTHS}, {@code YEARS},\n * {@code DECADES}, {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS}\n * are supported. Other {@code ChronoUnit} values will throw an exception.\n * \n * If the unit is not a {@code ChronoUnit}, then the result of this method\n * is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)}\n * passing {@code this} as the first argument and the input temporal as\n * the second argument.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param endExclusive the end date, which is converted to a {@code LocalDate}, not null\n * @param unit the unit to measure the period in, not null\n * @return the amount of the period between this date and the end date\n * @throws DateTimeException if the period cannot be calculated\n * @throws ArithmeticException if numeric overflow occurs\n */\n _until2(endExclusive, unit) {\n var end = LocalDate.from(endExclusive);\n if (unit instanceof ChronoUnit) {\n switch (unit) {\n case ChronoUnit.DAYS: return this.daysUntil(end);\n case ChronoUnit.WEEKS: return this.daysUntil(end) / 7;\n case ChronoUnit.MONTHS: return this.monthsUntil(end);\n case ChronoUnit.YEARS: return this.monthsUntil(end) / 12;\n case ChronoUnit.DECADES: return this.monthsUntil(end) / 120;\n case ChronoUnit.CENTURIES: return this.monthsUntil(end) / 1200;\n case ChronoUnit.MILLENNIA: return this.monthsUntil(end) / 12000;\n case ChronoUnit.ERAS: return end.getLong(ChronoField.ERA) - this.getLong(ChronoField.ERA);\n }\n throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);\n }\n return unit.between(this, end);\n }\n\n daysUntil(end) {\n return end.toEpochDay() - this.toEpochDay(); // no overflow\n }\n\n monthsUntil(end) {\n var packed1 = this._prolepticMonth() * 32 + this.dayOfMonth(); // no overflow\n var packed2 = end._prolepticMonth() * 32 + end.dayOfMonth(); // no overflow\n return MathUtil.floorDiv((packed2 - packed1), 32);\n }\n\n /**\n * Calculates the period between this date and another date as a {@code Period}.\n * \n * This calculates the period between two dates in terms of years, months and days.\n * The start and end points are {@code this} and the specified date.\n * The result will be negative if the end is before the start.\n * \n * The calculation is performed using the ISO calendar system.\n * If necessary, the input date will be converted to ISO.\n * \n * The start date is included, but the end date is not.\n * The period is calculated by removing complete months, then calculating\n * the remaining number of days, adjusting to ensure that both have the same sign.\n * The number of months is then normalized into years and months based on a 12 month year.\n * A month is considered to be complete if the end day-of-month is greater\n * than or equal to the start day-of-month.\n * For example, from {@code 2010-01-15} to {@code 2011-03-18} is \"1 year, 2 months and 3 days\".\n * \n * The result of this method can be a negative period if the end is before the start.\n * The negative sign will be the same in each of year, month and day.\n * \n * There are two equivalent ways of using this method.\n * The first is to invoke this method.\n * The second is to use {@link Period#between(LocalDate, LocalDate)}:\n * \n * The comparison is primarily based on the date, from earliest to latest.\n * It is \"consistent with equals\", as defined by {@link Comparable}.\n * \n * If all the dates being compared are instances of {@code LocalDate},\n * then the comparison will be entirely based on the date.\n * If some dates being compared are in different chronologies, then the\n * chronology is also considered, see {@link ChronoLocalDate#compareTo}.\n *\n * @param other the other date to compare to, not null\n * @return the comparator value, negative if less, positive if greater\n */\n compareTo(other) {\n requireNonNull(other, 'other');\n requireInstance(other, LocalDate, 'other');\n if (other instanceof LocalDate) {\n return this._compareTo0(other);\n }\n // super.compareTo(other);\n }\n\n _compareTo0(otherDate) {\n var cmp = (this._year - otherDate._year);\n if (cmp === 0) {\n cmp = (this._month - otherDate._month);\n if (cmp === 0) {\n cmp = (this._day - otherDate._day);\n }\n }\n return cmp;\n }\n\n /**\n * Checks if this date is after the specified date.\n * \n * This checks to see if this date represents a point on the\n * local time-line after the other date.\n * \n * This method only considers the position of the two dates on the local time-line.\n * It does not take into account the chronology, or calendar system.\n * This is different from the comparison in {@link #compareTo(ChronoLocalDate)},\n * but is the same approach as {@link #DATE_COMPARATOR}.\n *\n * @param other the other date to compare to, not null\n * @return true if this date is after the specified date\n */\n isAfter(other) {\n return this.compareTo(other) > 0;\n // return super.isAfter(other) if not instanceof LocalDate\n }\n\n /**\n * Checks if this date is before the specified date.\n * \n * This checks to see if this date represents a point on the\n * local time-line before the other date.\n * \n * This method only considers the position of the two dates on the local time-line.\n * It does not take into account the chronology, or calendar system.\n * This is different from the comparison in {@link #compareTo(ChronoLocalDate)},\n * but is the same approach as {@link #DATE_COMPARATOR}.\n *\n * @param other the other date to compare to, not null\n * @return true if this date is before the specified date\n */\n isBefore(other) {\n return this.compareTo(other) < 0;\n // return super.isBefore(other) if not instanceof LocalDate\n }\n\n /**\n * Checks if this date is equal to the specified date.\n * \n * This checks to see if this date represents the same point on the\n * local time-line as the other date.\n * \n * This method only considers the position of the two dates on the local time-line.\n * It does not take into account the chronology, or calendar system.\n * This is different from the comparison in {@link #compareTo(ChronoLocalDate)}\n * but is the same approach as {@link #DATE_COMPARATOR}.\n *\n * @param other the other date to compare to, not null\n * @return true if this date is equal to the specified date\n */\n isEqual(other) {\n return this.compareTo(other) === 0;\n // return super.isEqual(other) if not instanceof LocalDate\n }\n\n /**\n * Checks if this date is equal to another date.\n *\n * Compares this LocalDate with another ensuring that the date is the same.\n *\n * Only objects of type LocalDate are compared, other types return false.\n *\n * @param otherDate the object to check, null returns false\n * @return true if this is equal to the other date\n */\n equals(otherDate) {\n if (this === otherDate) {\n return true;\n }\n if (otherDate instanceof LocalDate) {\n return this._compareTo0(otherDate) === 0;\n }\n return false;\n }\n\n /**\n * A hash code for this date.\n *\n * @return a suitable hash code\n */\n hashCode() {\n var yearValue = this._year;\n var monthValue = this._month;\n var dayValue = this._day;\n return (yearValue & 0xFFFFF800) ^ ((yearValue << 11) + (monthValue << 6) + (dayValue));\n }\n\n /**\n * Outputs this date as a String, such as 2007-12-03.\n * The output will be in the ISO-8601 format uuuu-MM-dd.\n *\n * @return {string} a string representation of this date, not null\n */\n toString() {\n var dayString, monthString, yearString;\n\n var yearValue = this.year();\n var monthValue = this.monthValue();\n var dayValue = this.dayOfMonth();\n\n var absYear = Math.abs(yearValue);\n\n if (absYear < 1000) {\n if (yearValue < 0) {\n yearString = '-' + ('' + (yearValue - 10000)).slice(-4);\n } else {\n yearString = ('' + (yearValue + 10000)).slice(-4);\n }\n } else {\n if (yearValue > 9999) {\n yearString = '+' + yearValue;\n } else {\n yearString = '' + yearValue;\n }\n }\n\n if (monthValue < 10) {\n monthString = '-0' + monthValue;\n } else {\n monthString = '-' + monthValue;\n }\n\n if (dayValue < 10) {\n dayString = '-0' + dayValue;\n } else {\n dayString = '-' + dayValue;\n }\n\n return yearString + monthString + dayString;\n }\n}\n\nexport function _init() {\n /**\n * The minimum supported {@code LocalDate}\n * This could be used by an application as a \"far past\" date.\n */\n LocalDate.MIN = LocalDate.of(Year.MIN_VALUE, 1, 1);\n /**\n * The maximum supported {@code LocalDate}\n * This could be used by an application as a \"far future\" date.\n */\n LocalDate.MAX = LocalDate.of(Year.MAX_VALUE, 12, 31);\n\n LocalDate.FROM = createTemporalQuery('LocalDate.FROM', (temporal) => {\n return LocalDate.from(temporal);\n });\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/LocalDate.js\n **/","import {ChronoField} from '../temporal/ChronoField';\nimport {ChronoUnit} from '../temporal/ChronoUnit';\nimport {TemporalQueries} from '../temporal/TemporalQueries';\nimport {TemporalAccessor} from '../temporal/TemporalAccessor';\n\nimport {LocalDate} from '../LocalDate';\n\nexport class ChronoLocalDate extends TemporalAccessor {\n\n isSupported(fieldOrUnit) {\n if (fieldOrUnit instanceof ChronoField) {\n return fieldOrUnit.isDateBased();\n } else if (fieldOrUnit instanceof ChronoUnit) {\n return fieldOrUnit.isDateBased();\n }\n return fieldOrUnit != null && fieldOrUnit.isSupportedBy(this);\n }\n\n query(query) {\n if (query === TemporalQueries.chronology()) {\n return this.chronology();\n } else if (query === TemporalQueries.precision()) {\n return ChronoUnit.DAYS;\n } else if (query === TemporalQueries.localDate()) {\n return LocalDate.ofEpochDay(this.toEpochDay());\n } else if (query === TemporalQueries.localTime() || query === TemporalQueries.zone() ||\n query === TemporalQueries.zoneId() || query === TemporalQueries.offset()) {\n return null;\n }\n return super.query(query);\n }\n\n adjustInto(temporal) {\n return temporal.with(ChronoField.EPOCH_DAY, this.toEpochDay());\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/chrono/ChronoLocalDate.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport {Enum} from '../Enum';\n\nimport {ChronoField} from './ChronoField';\n\nimport {LocalDate} from '../LocalDate';\nimport {LocalTime} from '../LocalTime';\nimport {ZoneOffset} from '../ZoneOffset';\n\n/**\n * Common implementations of {@code TemporalQuery}.\n * \n * This class provides common implementations of {@link TemporalQuery}.\n * These queries are primarily used as optimizations, allowing the internals\n * of other objects to be extracted effectively. Note that application code\n * can also use the {@code from(TemporalAccessor)} method on most temporal\n * objects as a method reference matching the query interface, such as\n * {@code LocalDate::from} and {@code ZoneId::from}.\n * \n * There are two equivalent ways of using a {@code TemporalQuery}.\n * The first is to invoke the method on the interface directly.\n * The second is to use {@link TemporalAccessor#query(TemporalQuery)}:\n * \n * This queries a {@code TemporalAccessor} for the zone.\n * The zone is only returned if the date-time conceptually contains a {@code ZoneId}.\n * It will not be returned if the date-time only conceptually has an {@code ZoneOffset}.\n * Thus a {@link ZonedDateTime} will return the result of\n * {@code getZone()}, but an {@link OffsetDateTime} will\n * return null.\n * \n * In most cases, applications should use {@link #ZONE} as this query is too strict.\n * \n * The result from JDK classes implementing {@code TemporalAccessor} is as follows: \n * This queries a {@code TemporalAccessor} for the chronology.\n * If the target {@code TemporalAccessor} represents a date, or part of a date,\n * then it should return the chronology that the date is expressed in.\n * As a result of this definition, objects only representing time, such as\n * {@code LocalTime}, will return null.\n * \n * The result from js-joda classes implementing {@code TemporalAccessor} is as follows: \n * The method {@link Chronology#from(TemporalAccessor)} can be used as a\n * {@code TemporalQuery}\n * That method is equivalent to this query, except that it throws an\n * exception if a chronology cannot be obtained.\n *\n * @return a query that can obtain the chronology of a temporal, not null\n */\n static chronology() {\n return TemporalQueries.CHRONO;\n }\n\n /**\n * A query for the smallest supported unit.\n * \n * This queries a {@code TemporalAccessor} for the time precision.\n * If the target {@code TemporalAccessor} represents a consistent or complete date-time,\n * date or time then this must return the smallest precision actually supported.\n * Note that fields such as {@code NANO_OF_DAY} and {@code NANO_OF_SECOND}\n * are defined to always return ignoring the precision, thus this is the only\n * way to find the actual smallest supported unit.\n * For example, were {@code GregorianCalendar} to implement {@code TemporalAccessor}\n * it would return a precision of {@code MILLIS}.\n * \n * The result from js-joda classes implementing {@code TemporalAccessor} is as follows: \n * This queries a {@code TemporalAccessor} for the zone.\n * It first tries to obtain the zone, using {@link #zoneId()}.\n * If that is not found it tries to obtain the {@link #offset()}.\n * \n * In most cases, applications should use this query rather than {@code #zoneId()}.\n * \n * This query examines the {@link ChronoField#OFFSET_SECONDS offset-seconds}\n * field and uses it to create a {@code ZoneOffset}.\n * \n * The method {@link ZoneId#from(TemporalAccessor)} can be used as a\n * {@code TemporalQuery} via a method reference, {@code ZoneId::from}.\n * That method is equivalent to this query, except that it throws an\n * exception if a zone cannot be obtained.\n *\n * @return a query that can obtain the zone ID or offset of a temporal, not null\n */\n static zone() {\n return TemporalQueries.ZONE;\n }\n\n /**\n * A query for {@code ZoneOffset} returning null if not found.\n * \n * This returns a {@code TemporalQuery} that can be used to query a temporal\n * object for the offset. The query will return null if the temporal\n * object cannot supply an offset.\n * \n * The query implementation examines the {@link ChronoField#OFFSET_SECONDS OFFSET_SECONDS}\n * field and uses it to create a {@code ZoneOffset}.\n * \n * The method {@link java.time.ZoneOffset#from(TemporalAccessor)} can be used as a\n * {@code TemporalQuery} via a method reference, {@code ZoneOffset::from}.\n * This query and {@code ZoneOffset::from} will return the same result if the\n * temporal object contains an offset. If the temporal object does not contain\n * an offset, then the method reference will throw an exception, whereas this\n * query will return null.\n *\n * @return a query that can obtain the offset of a temporal, not null\n */\n static offset() {\n return TemporalQueries.OFFSET;\n }\n\n /**\n * A query for {@code LocalDate} returning null if not found.\n * \n * This returns a {@code TemporalQuery} that can be used to query a temporal\n * object for the local date. The query will return null if the temporal\n * object cannot supply a local date.\n * \n * The query implementation examines the {@link ChronoField#EPOCH_DAY EPOCH_DAY}\n * field and uses it to create a {@code LocalDate}.\n *\n * @return a query that can obtain the date of a temporal, not null\n */\n static localDate() {\n return TemporalQueries.LOCAL_DATE;\n }\n\n /**\n * A query for {@code LocalTime} returning null if not found.\n * \n * This returns a {@code TemporalQuery} that can be used to query a temporal\n * object for the local time. The query will return null if the temporal\n * object cannot supply a local time.\n * \n * The query implementation examines the {@link ChronoField#NANO_OF_DAY NANO_OF_DAY}\n * field and uses it to create a {@code LocalTime}.\n *\n * @return a query that can obtain the time of a temporal, not null\n */\n static localTime() {\n return TemporalQueries.LOCAL_TIME;\n }\n}\n\n/** \n * Factory to create something similar to the JSR-310 {TemporalQuery} interface, takes a function and returns a new TemporalQuery object that presents that function\n * as the queryFrom() function.\n * TODO: maybe should be moved to a separate file?\n * @param name\n * @param queryFromFunction\n */\nexport function createTemporalQuery(name, queryFromFunction) {\n class TemporalQuery extends Enum {\n }\n TemporalQuery.prototype.queryFrom = queryFromFunction; \n return new TemporalQuery(name);\n}\n\nexport function _init() {\n //-----------------------------------------------------------------------\n /**\n * A strict query for the {@code ZoneId}.\n */\n TemporalQueries.ZONE_ID = createTemporalQuery('ZONE_ID', (temporal) => {\n return temporal.query(TemporalQueries.ZONE_ID);\n });\n\n /**\n * A query for the {@code Chronology}.\n */\n TemporalQueries.CHRONO = createTemporalQuery('CHRONO', (temporal) => {\n return temporal.query(TemporalQueries.CHRONO);\n });\n\n /**\n * A query for the smallest supported unit.\n */\n TemporalQueries.PRECISION = createTemporalQuery('PRECISION', (temporal) => {\n return temporal.query(TemporalQueries.PRECISION);\n });\n\n //-----------------------------------------------------------------------\n /**\n * A query for {@code ZoneOffset} returning null if not found.\n */\n TemporalQueries.OFFSET = createTemporalQuery('OFFSET', (temporal) => {\n if (temporal.isSupported(ChronoField.OFFSET_SECONDS)) {\n return ZoneOffset.ofTotalSeconds(temporal.get(TemporalQueries.OFFSET_SECONDS));\n }\n return null;\n });\n\n /**\n * A lenient query for the {@code ZoneId}, falling back to the {@code ZoneOffset}.\n */\n TemporalQueries.ZONE = createTemporalQuery('ZONE', (temporal) => {\n var zone = temporal.query(TemporalQueries.ZONE_ID);\n return (zone != null ? zone : temporal.query(TemporalQueries.OFFSET));\n });\n\n /**\n * A query for {@code LocalDate} returning null if not found.\n */\n TemporalQueries.LOCAL_DATE = createTemporalQuery('LOCAL_DATE', (temporal) => {\n if (temporal.isSupported(ChronoField.EPOCH_DAY)) {\n return LocalDate.ofEpochDay(temporal.getLong(TemporalQueries.EPOCH_DAY));\n }\n return null;\n });\n\n /**\n * A query for {@code LocalTime} returning null if not found.\n */\n TemporalQueries.LOCAL_TIME = createTemporalQuery('LOCAL_TIME', (temporal) => {\n if (temporal.isSupported(ChronoField.NANO_OF_DAY)) {\n return LocalTime.ofNanoOfDay(temporal.getLong(TemporalQueries.NANO_OF_DAY));\n }\n return null;\n });\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/temporal/TemporalQueries.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {DateTimeException} from './errors';\nimport {LocalTime} from './LocalTime';\n\nexport class ZoneOffset {\n constructor(totalSeconds){\n ZoneOffset.validateTotalSeconds(totalSeconds);\n this._totalSeconds = totalSeconds;\n }\n\n totalSeconds() {\n return this._totalSeconds;\n }\n\n /**\n * Checks if this offset is equal to another offset.\n *\n * The comparison is based on the amount of the offset in seconds.\n * This is equivalent to a comparison by ID.\n *\n * @param obj the object to check, null returns false\n * @return true if this is equal to the other offset\n */\n equals(obj) {\n if (this === obj) {\n return true;\n }\n if (obj instanceof ZoneOffset) {\n return this._totalSeconds === obj._totalSeconds;\n }\n return false;\n }\n\n static validateTotalSeconds(totalSeconds){\n if (Math.abs(totalSeconds) > ZoneOffset.MAX_SECONDS) {\n throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');\n }\n }\n\n static validate(hours, minutes, seconds) {\n if (hours < -18 || hours > 18) {\n throw new DateTimeException('Zone offset hours not in valid range: value ' + hours +\n ' is not in the range -18 to 18');\n }\n if (hours > 0) {\n if (minutes < 0 || seconds < 0) {\n throw new DateTimeException('Zone offset minutes and seconds must be positive because hours is positive');\n }\n } else if (hours < 0) {\n if (minutes > 0 || seconds > 0) {\n throw new DateTimeException('Zone offset minutes and seconds must be negative because hours is negative');\n }\n } else if ((minutes > 0 && seconds < 0) || (minutes < 0 && seconds > 0)) {\n throw new DateTimeException('Zone offset minutes and seconds must have the same sign');\n }\n if (Math.abs(minutes) > 59) {\n throw new DateTimeException('Zone offset minutes not in valid range: abs(value) ' +\n Math.abs(minutes) + ' is not in the range 0 to 59');\n }\n if (Math.abs(seconds) > 59) {\n throw new DateTimeException('Zone offset seconds not in valid range: abs(value) ' +\n Math.abs(seconds) + ' is not in the range 0 to 59');\n }\n if (Math.abs(hours) === 18 && (Math.abs(minutes) > 0 || Math.abs(seconds) > 0)) {\n throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');\n }\n }\n\n static ofHours(hours) {\n return ZoneOffset.ofHoursMinutesSeconds(hours, 0, 0);\n }\n\n static ofHoursMinutes(hours, minutes) {\n return ZoneOffset.ofHoursMinutesSeconds(hours, minutes, 0);\n }\n\n static ofHoursMinutesSeconds(hours, minutes, seconds) {\n ZoneOffset.validate(hours, minutes, seconds);\n var totalSeconds = hours * LocalTime.SECONDS_PER_HOUR + minutes * LocalTime.SECONDS_PER_MINUTE + seconds;\n return ZoneOffset.ofTotalSeconds(totalSeconds);\n }\n\n static ofTotalMinutes(totalMinutes) {\n var totalSeconds = totalMinutes * LocalTime.SECONDS_PER_MINUTE;\n return ZoneOffset.ofTotalSeconds(totalSeconds);\n }\n\n static ofTotalSeconds(totalSeconds) {\n if (totalSeconds % (15 * LocalTime.SECONDS_PER_MINUTE) === 0) {\n var totalSecs = totalSeconds;\n var result = ZoneOffset.SECONDS_CACHE[totalSecs];\n if (result == null) {\n result = new ZoneOffset(totalSeconds);\n ZoneOffset.SECONDS_CACHE[totalSecs] = result;\n }\n return result;\n } else {\n return new ZoneOffset(totalSeconds);\n }\n }\n\n}\n\nexport function _init() {\n ZoneOffset.MAX_SECONDS = 18 * LocalTime.SECONDS_PER_HOUR;\n ZoneOffset.SECONDS_CACHE = {};\n ZoneOffset.UTC = ZoneOffset.ofTotalSeconds(0);\n ZoneOffset.MIN = ZoneOffset.ofTotalSeconds(-ZoneOffset.MAX_SECONDS);\n ZoneOffset.MAX = ZoneOffset.ofTotalSeconds(ZoneOffset.MAX_SECONDS);\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/ZoneOffset.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {ChronoField} from './ChronoField';\nimport {TemporalQueries} from './TemporalQueries';\nimport {UnsupportedTemporalTypeException} from '../errors';\n\nexport class TemporalAccessor {\n /**\n * Queries this date-time.\n * \n * This queries this date-time using the specified query strategy object.\n * \n * Queries are a key tool for extracting information from date-times.\n * They exists to externalize the process of querying, permitting different\n * approaches, as per the strategy design pattern.\n * Examples might be a query that checks if the date is the day before February 29th\n * in a leap year, or calculates the number of days to your next birthday.\n * \n * The most common query implementations are method references, such as\n * {@code LocalDate::from} and {@code ZoneId::from}.\n * Further implementations are on {@link TemporalQueries}.\n * Queries may also be defined by applications.\n *\n * @implSpec\n * Implementations of this method must behave as follows:\n * \n * All fields can be expressed as a {@code long} integer.\n * This method returns an object that describes the valid range for that value.\n * The value of this temporal object is used to enhance the accuracy of the returned range.\n * If the date-time cannot return the range, because the field is unsupported or for\n * some other reason, an exception will be thrown.\n * \n * Note that the result only describes the minimum and maximum valid values\n * and it is important not to read too much into them. For example, there\n * could be values within the range that are invalid for the field.\n *\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.rangeRefinedBy(TemporalAccessorl)}\n * passing {@code this} as the argument.\n * \n * Implementations must not alter either this object.\n *\n * @param {TemporalField} field the field to query the range for, not null\n * @return {ValueRange} the range of valid values for the field, not null\n * @throws DateTimeException if the range for the field cannot be obtained\n */\n range(field) {\n if (field instanceof ChronoField) {\n if (this.isSupported(field)) {\n return field.range();\n }\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n return field.rangeRefinedBy(this);\n }\n\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/temporal/TemporalAccessor.js\n **/","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper \n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos \n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport {DateTimeException, UnsupportedTemporalTypeException, NullPointerException} from './errors';\nimport {MathUtil} from './MathUtil';\nimport {assert} from './assert';\n\nimport {DateTimeFormatterBuilder} from './format/DateTimeFormatterBuilder';\n\nimport {ChronoField} from './temporal/ChronoField';\nimport {ChronoUnit} from './temporal/ChronoUnit';\nimport {TemporalAccessor} from './temporal/TemporalAccessor';\nimport {TemporalQueries, createTemporalQuery} from './temporal/TemporalQueries';\n\nexport class DayOfWeek extends TemporalAccessor {\n \n constructor(ordinal, name){\n super();\n this._ordinal = ordinal;\n this._name = name;\n }\n\n ordinal(){\n return this._ordinal;\n }\n\n name(){\n return this._name;\n }\n\n static values() {\n return ENUMS.slice();\n }\n\n static valueOf(name) {\n for(var ordinal=0; ordinal < ENUMS.length; ordinal++){\n if(ENUMS[ordinal].name() === name){\n break;\n }\n }\n return DayOfWeek.of(ordinal+1);\n }\n \n /**\n * Obtains an instance of {@code DayOfWeek} from an {@code int} value.\n * \n * {@code DayOfWeek} is an enum representing the 7 days of the week.\n * This factory allows the enum to be obtained from the {@code int} value.\n * The {@code int} value follows the ISO-8601 standard, from 1 (Monday) to 7 (Sunday).\n *\n * @param dayOfWeek the day-of-week to represent, from 1 (Monday) to 7 (Sunday)\n * @return the day-of-week singleton, not null\n * @throws DateTimeException if the day-of-week is invalid\n */\n static of(dayOfWeek) {\n if (dayOfWeek < 1 || dayOfWeek > 7) {\n throw new DateTimeException('Invalid value for DayOfWeek: ' + dayOfWeek);\n }\n return ENUMS[dayOfWeek - 1];\n }\n \n /**\n * Obtains an instance of {@code DayOfWeek} from a temporal object.\n * \n * A {@code TemporalAccessor} represents some form of date and time information.\n * This factory converts the arbitrary temporal object to an instance of {@code DayOfWeek}.\n * \n * The conversion extracts the {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} field.\n * \n * This method matches the signature of the functional interface {@link TemporalQuery}\n * allowing it to be used as a query via method reference, {@code DayOfWeek::from}.\n *\n * @param temporal the temporal object to convert, not null\n * @return the day-of-week, not null\n * @throws DateTimeException if unable to convert to a {@code DayOfWeek}\n */\n static from(temporal) {\n assert(temporal != null, 'temporal', NullPointerException);\n if (temporal instanceof DayOfWeek) {\n return temporal;\n }\n try {\n return DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));\n } catch (ex) {\n if(ex instanceof DateTimeException) {\n throw new DateTimeException('Unable to obtain DayOfWeek from TemporalAccessor: ' +\n temporal + ', type ' + temporal.name(), ex);\n } else {\n throw ex;\n }\n }\n }\n\n /**\n * Gets the day-of-week {@code int} value.\n * \n * The values are numbered following the ISO-8601 standard, from 1 (Monday) to 7 (Sunday).\n * See {@link WeekFields#dayOfWeek} for localized week-numbering.\n *\n * @return the day-of-week, from 1 (Monday) to 7 (Sunday)\n */\n value() {\n return this._ordinal + 1;\n }\n\n /**\n * Gets the textual representation, such as 'Mon' or 'Friday'.\n * \n * This returns the textual name used to identify the day-of-week.\n * The parameters control the length of the returned text and the locale.\n * \n * If no textual mapping is found then the {@link #getValue() numeric value} is returned.\n *\n * @param style the length of the text required, not null\n * @param locale the locale to use, not null\n * @return the text value of the day-of-week, not null\n */\n getDisplayName(style, locale) {\n return new DateTimeFormatterBuilder().appendText(ChronoField.DAY_OF_WEEK, style).toFormatter(locale).format(this);\n }\n\n /**\n * Checks if the specified field is supported.\n * \n * This checks if this day-of-week can be queried for the specified field.\n * If false, then calling the {@link #range(TemporalField) range} and\n * {@link #get(TemporalField) get} methods will throw an exception.\n * \n * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then\n * this method returns true.\n * All other {@code ChronoField} instances will return false.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}\n * passing {@code this} as the argument.\n * Whether the field is supported is determined by the field.\n *\n * @param field the field to check, null returns false\n * @return true if the field is supported on this day-of-week, false if not\n */\n isSupported(field) {\n if (field instanceof ChronoField) {\n return field === ChronoField.DAY_OF_WEEK;\n }\n return field != null && field.isSupportedBy(this);\n }\n\n /**\n * Gets the range of valid values for the specified field.\n * \n * The range object expresses the minimum and maximum valid values for a field.\n * This day-of-week is used to enhance the accuracy of the returned range.\n * If it is not possible to return the range, because the field is not supported\n * or for some other reason, an exception is thrown.\n * \n * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the\n * range of the day-of-week, from 1 to 7, will be returned.\n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)}\n * passing {@code this} as the argument.\n * Whether the range can be obtained is determined by the field.\n *\n * @param field the field to query the range for, not null\n * @return the range of valid values for the field, not null\n * @throws DateTimeException if the range for the field cannot be obtained\n */\n range(field) {\n if (field === ChronoField.DAY_OF_WEEK) {\n return field.range();\n } else if (field instanceof ChronoField) {\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n return field.rangeRefinedBy(this);\n }\n\n /**\n * Gets the value of the specified field from this day-of-week as an {@code int}.\n * \n * This queries this day-of-week for the value for the specified field.\n * The returned value will always be within the valid range of values for the field.\n * If it is not possible to return the value, because the field is not supported\n * or for some other reason, an exception is thrown.\n * \n * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the\n * value of the day-of-week, from 1 to 7, will be returned.\n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}\n * passing {@code this} as the argument. Whether the value can be obtained,\n * and what the value represents, is determined by the field.\n *\n * @param field the field to get, not null\n * @return the value for the field, within the valid range of values\n * @throws DateTimeException if a value for the field cannot be obtained\n * @throws DateTimeException if the range of valid values for the field exceeds an {@code int}\n * @throws DateTimeException if the value is outside the range of valid values for the field\n * @throws ArithmeticException if numeric overflow occurs\n */\n get(field) {\n if (field === ChronoField.DAY_OF_WEEK) {\n return this.value();\n }\n return this.range(field).checkValidIntValue(this.getLong(field), field);\n }\n\n /**\n * Gets the value of the specified field from this day-of-week as a {@code long}.\n * \n * This queries this day-of-week for the value for the specified field.\n * If it is not possible to return the value, because the field is not supported\n * or for some other reason, an exception is thrown.\n * \n * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the\n * value of the day-of-week, from 1 to 7, will be returned.\n * All other {@code ChronoField} instances will throw a {@code DateTimeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}\n * passing {@code this} as the argument. Whether the value can be obtained,\n * and what the value represents, is determined by the field.\n *\n * @param field the field to get, not null\n * @return the value for the field\n * @throws DateTimeException if a value for the field cannot be obtained\n * @throws ArithmeticException if numeric overflow occurs\n */\n getLong(field) {\n if (field === ChronoField.DAY_OF_WEEK) {\n return this.value();\n } else if (field instanceof ChronoField) {\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n return field.getFrom(this);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns the day-of-week that is the specified number of days after this one.\n * \n * The calculation rolls around the end of the week from Sunday to Monday.\n * The specified period may be negative.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param days the days to add, positive or negative\n * @return the resulting day-of-week, not null\n */\n plus(days) {\n var amount = MathUtil.floorMod(days, 7);\n return ENUMS[MathUtil.floorMod(this._ordinal + (amount + 7), 7)];\n }\n\n /**\n * Returns the day-of-week that is the specified number of days before this one.\n * \n * The calculation rolls around the start of the year from Monday to Sunday.\n * The specified period may be negative.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param days the days to subtract, positive or negative\n * @return the resulting day-of-week, not null\n */\n minus(days) {\n return this.plus(-1 * MathUtil.floorMod(days, 7));\n }\n\n //-----------------------------------------------------------------------\n /**\n * Queries this day-of-week using the specified query.\n * \n * This queries this day-of-week using the specified query strategy object.\n * The {@code TemporalQuery} object defines the logic to be used to\n * obtain the result. Read the documentation of the query to understand\n * what the result of this method will be.\n * \n * The result of this method is obtained by invoking the\n * {@link TemporalQuery#queryFrom(TemporalAccessor)} method on the\n * specified query passing {@code this} as the argument.\n *\n * @param query the query to invoke, not null\n * @return the query result, null may be returned (defined by the query)\n * @throws DateTimeException if unable to query (defined by the query)\n * @throws ArithmeticException if numeric overflow occurs (defined by the query)\n */\n query(query) {\n if (query === TemporalQueries.precision()) {\n return ChronoUnit.DAYS;\n } else if (query === TemporalQueries.localDate() || query === TemporalQueries.localTime() || query === TemporalQueries.chronology() ||\n query === TemporalQueries.zone() || query === TemporalQueries.zoneId() || query === TemporalQueries.offset()) {\n return null;\n }\n assert(query != null, 'query', NullPointerException);\n return query.queryFrom(this);\n }\n\n /**\n * Adjusts the specified temporal object to have this day-of-week.\n * \n * This returns a temporal object of the same observable type as the input\n * with the day-of-week changed to be the same as this.\n * \n * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}\n * passing {@link ChronoField#DAY_OF_WEEK} as the field.\n * Note that this adjusts forwards or backwards within a Monday to Sunday week.\n * See {@link WeekFields#dayOfWeek} for localized week start days.\n * See {@link TemporalAdjusters} for other adjusters\n * with more control, such as {@code next(MONDAY)}.\n * \n * In most cases, it is clearer to reverse the calling pattern by using\n * {@link Temporal#with(TemporalAdjuster)}:\n * \n * For example, given a date that is a Wednesday, the following are output:\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param temporal the target object to be adjusted, not null\n * @return the adjusted object, not null\n * @throws DateTimeException if unable to make the adjustment\n * @throws ArithmeticException if numeric overflow occurs\n */\n adjustInto(temporal) {\n return temporal.with(ChronoField.DAY_OF_WEEK, this.value());\n }\n\n equal(){\n return this._name;\n }\n\n toString(){\n return this._name;\n }\n}\n\nvar ENUMS;\n\nexport function _init() {\n DayOfWeek.MONDAY = new DayOfWeek(0, 'MONDAY');\n DayOfWeek.TUESDAY = new DayOfWeek(1, 'TUESDAY');\n DayOfWeek.WEDNESDAY = new DayOfWeek(2, 'WEDNESDAY');\n DayOfWeek.THURSDAY = new DayOfWeek(3, 'THURSDAY');\n DayOfWeek.FRIDAY = new DayOfWeek(4, 'FRIDAY');\n DayOfWeek.SATURDAY = new DayOfWeek(5, 'SATURDAY');\n DayOfWeek.SUNDAY = new DayOfWeek(6, 'SUNDAY');\n\n DayOfWeek.FROM = createTemporalQuery('DayOfWeek.FROM', (temporal) => {\n return DayOfWeek.from(temporal);\n });\n\n ENUMS = [\n DayOfWeek.MONDAY,\n DayOfWeek.TUESDAY,\n DayOfWeek.WEDNESDAY,\n DayOfWeek.THURSDAY,\n DayOfWeek.FRIDAY,\n DayOfWeek.SATURDAY,\n DayOfWeek.SUNDAY\n ];\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/DayOfWeek.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport {assert} from '../assert';\nimport {ArithmeticException, DateTimeException, IllegalArgumentException} from '../errors';\n\nimport {Enum} from '../Enum';\n\nimport {DateTimeFormatter} from './DateTimeFormatter';\nimport {DecimalStyle} from './DecimalStyle';\nimport {SignStyle} from './SignStyle';\nimport {ResolverStyle} from './ResolverStyle';\n\nconst MAX_WIDTH = 15; // can't parse all numbers with more then 15 digits in javascript\n\nexport class DateTimeFormatterBuilder {\n\n constructor(){\n /**\n * The currently active builder, used by the outermost builder.\n */\n this._active = this;\n /**\n * The parent builder, null for the outermost builder.\n */\n this._parent = null;\n\n /**\n * The list of printers that will be used.\n */\n this._printerParsers = [];\n\n /**\n * Whether this builder produces an optional formatter.\n */\n this._optional = false;\n /**\n * The width to pad the next field to.\n */\n this._padNextWidth = 0;\n\n /**\n * The character to pad the next field with.\n */\n this._padNextChar = null;\n\n /**\n * The index of the last variable width value parser.\n */\n this._valueParserIndex = -1;\n }\n\n /**\n * Changes the parse style to be case sensitive for the remainder of the formatter.\n * \n * Parsing can be case sensitive or insensitive - by default it is case sensitive.\n * This method allows the case sensitivity setting of parsing to be changed.\n * \n * Calling this method changes the state of the builder such that all\n * subsequent builder method calls will parse text in case sensitive mode.\n * See {@link #parseCaseInsensitive} for the opposite setting.\n * The parse case sensitive/insensitive methods may be called at any point\n * in the builder, thus the parser can swap between case parsing modes\n * multiple times during the parse.\n * \n * Since the default is case sensitive, this method should only be used after\n * a previous call to {@code #parseCaseInsensitive}.\n *\n * @return this, for chaining, not null\n */\n parseCaseSensitive() {\n this._appendInternalPrinterParser(SettingsParser.SENSITIVE);\n return this;\n }\n\n /**\n * Changes the parse style to be case insensitive for the remainder of the formatter.\n * \n * Parsing can be case sensitive or insensitive - by default it is case sensitive.\n * This method allows the case sensitivity setting of parsing to be changed.\n * \n * Calling this method changes the state of the builder such that all\n * subsequent builder method calls will parse text in case sensitive mode.\n * See {@link #parseCaseSensitive()} for the opposite setting.\n * The parse case sensitive/insensitive methods may be called at any point\n * in the builder, thus the parser can swap between case parsing modes\n * multiple times during the parse.\n *\n * @return this, for chaining, not null\n */\n parseCaseInsensitive() {\n this._appendInternalPrinterParser(SettingsParser.INSENSITIVE);\n return this;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Changes the parse style to be strict for the remainder of the formatter.\n * \n * Parsing can be strict or lenient - by default its strict.\n * This controls the degree of flexibility in matching the text and sign styles.\n * \n * When used, this method changes the parsing to be strict from this point onwards.\n * As strict is the default, this is normally only needed after calling {@link #parseLenient()}.\n * The change will remain in force until the end of the formatter that is eventually\n * constructed or until {@code parseLenient} is called.\n *\n * @return this, for chaining, not null\n */\n parseStrict() {\n this._appendInternalPrinterParser(SettingsParser.STRICT);\n return this;\n }\n\n /**\n * Changes the parse style to be lenient for the remainder of the formatter.\n * Note that case sensitivity is set separately to this method.\n * \n * Parsing can be strict or lenient - by default its strict.\n * This controls the degree of flexibility in matching the text and sign styles.\n * Applications calling this method should typically also call {@link #parseCaseInsensitive()}.\n * \n * When used, this method changes the parsing to be strict from this point onwards.\n * The change will remain in force until the end of the formatter that is eventually\n * constructed or until {@code parseStrict} is called.\n *\n * @return this, for chaining, not null\n */\n parseLenient() {\n this._appendInternalPrinterParser(SettingsParser.LENIENT);\n return this;\n }\n\n /**\n * appendValue function overloading\n */\n appendValue(){\n if(arguments.length === 1){\n return this._appendValue1.apply(this, arguments);\n } else if(arguments.length === 2){\n return this._appendValue2.apply(this, arguments);\n } else {\n return this._appendValue4.apply(this, arguments);\n } \n }\n \n /**\n * Appends the value of a date-time field to the formatter using a normal\n * output style.\n * \n * The value of the field will be output during a print.\n * If the value cannot be obtained then an exception will be thrown.\n * \n * The value will be printed as per the normal print of an integer value.\n * Only negative numbers will be signed. No padding will be added.\n * \n * The parser for a variable width value such as this normally behaves greedily,\n * requiring one digit, but accepting as many digits as possible.\n * This behavior can be affected by 'adjacent value parsing'.\n * See {@link #appendValue(TemporalField, int)} for full details.\n *\n * @param field the field to append, not null\n * @return this, for chaining, not null\n */\n _appendValue1(field) {\n assert(field != null);\n this._appendValuePrinterParser(new NumberPrinterParser(field, 1, MAX_WIDTH, SignStyle.NORMAL));\n return this;\n }\n\n /**\n * Appends the value of a date-time field to the formatter using a fixed\n * width, zero-padded approach.\n * \n * The value of the field will be output during a print.\n * If the value cannot be obtained then an exception will be thrown.\n * \n * The value will be zero-padded on the left. If the size of the value\n * means that it cannot be printed within the width then an exception is thrown.\n * If the value of the field is negative then an exception is thrown during printing.\n * \n * This method supports a special technique of parsing known as 'adjacent value parsing'.\n * This technique solves the problem where a variable length value is followed by one or more\n * fixed length values. The standard parser is greedy, and thus it would normally\n * steal the digits that are needed by the fixed width value parsers that follow the\n * variable width one.\n * \n * No action is required to initiate 'adjacent value parsing'.\n * When a call to {@code appendValue} with a variable width is made, the builder\n * enters adjacent value parsing setup mode. If the immediately subsequent method\n * call or calls on the same builder are to this method, then the parser will reserve\n * space so that the fixed width values can be parsed.\n * \n * For example, consider {@code builder.appendValue(YEAR).appendValue(MONTH_OF_YEAR, 2);}\n * The year is a variable width parse of between 1 and 19 digits.\n * The month is a fixed width parse of 2 digits.\n * Because these were appended to the same builder immediately after one another,\n * the year parser will reserve two digits for the month to parse.\n * Thus, the text '201106' will correctly parse to a year of 2011 and a month of 6.\n * Without adjacent value parsing, the year would greedily parse all six digits and leave\n * nothing for the month.\n * \n * Adjacent value parsing applies to each set of fixed width not-negative values in the parser\n * that immediately follow any kind of variable width value.\n * Calling any other append method will end the setup of adjacent value parsing.\n * Thus, in the unlikely event that you need to avoid adjacent value parsing behavior,\n * simply add the {@code appendValue} to another {@code DateTimeFormatterBuilder}\n * and add that to this builder.\n * \n * If adjacent parsing is active, then parsing must match exactly the specified\n * number of digits in both strict and lenient modes.\n * In addition, no positive or negative sign is permitted.\n *\n * @param field the field to append, not null\n * @param width the width of the printed field, from 1 to 19\n * @return this, for chaining, not null\n * @throws IllegalArgumentException if the width is invalid\n */\n _appendValue2(field, width) {\n assert(field != null);\n if (width < 1 || width > MAX_WIDTH) {\n throw new IllegalArgumentException(`The width must be from 1 to ${MAX_WIDTH} inclusive but was ${width}`);\n }\n var pp = new NumberPrinterParser(field, width, width, SignStyle.NOT_NEGATIVE);\n this._appendValuePrinterParser(pp);\n return this;\n }\n\n /**\n * Appends the value of a date-time field to the formatter providing full\n * control over printing.\n * \n * The value of the field will be output during a print.\n * If the value cannot be obtained then an exception will be thrown.\n * \n * This method provides full control of the numeric formatting, including\n * zero-padding and the positive/negative sign.\n * \n * The parser for a variable width value such as this normally behaves greedily,\n * accepting as many digits as possible.\n * This behavior can be affected by 'adjacent value parsing'.\n * See {@link #appendValue(TemporalField, int)} for full details.\n * \n * In strict parsing mode, the minimum number of parsed digits is {@code minWidth}.\n * In lenient parsing mode, the minimum number of parsed digits is one.\n * \n * If this method is invoked with equal minimum and maximum widths and a sign style of\n * {@code NOT_NEGATIVE} then it delegates to {@code appendValue(TemporalField,int)}.\n * In this scenario, the printing and parsing behavior described there occur.\n *\n * @param field the field to append, not null\n * @param minWidth the minimum field width of the printed field, from 1 to 19\n * @param maxWidth the maximum field width of the printed field, from 1 to 19\n * @param signStyle the positive/negative output style, not null\n * @return this, for chaining, not null\n * @throws IllegalArgumentException if the widths are invalid\n */\n _appendValue4(field, minWidth, maxWidth, signStyle) {\n assert(field != null);\n if (minWidth === maxWidth && signStyle === SignStyle.NOT_NEGATIVE) {\n return this._appendValue2(field, maxWidth);\n }\n if (minWidth < 1 || minWidth > MAX_WIDTH) {\n throw new IllegalArgumentException(`The minimum width must be from 1 to ${MAX_WIDTH} inclusive but was ${minWidth}`);\n }\n if (maxWidth < 1 || maxWidth > MAX_WIDTH) {\n throw new IllegalArgumentException(`The minimum width must be from 1 to ${MAX_WIDTH} inclusive but was ${maxWidth}`);\n }\n if (maxWidth < minWidth) {\n throw new IllegalArgumentException(`The maximum width must exceed or equal the minimum width but ${maxWidth} < ${minWidth}`);\n }\n var pp = new NumberPrinterParser(field, minWidth, maxWidth, signStyle);\n this._appendValuePrinterParser(pp);\n return this;\n }\n\n /**\n * Appends a fixed width printer-parser.\n *\n * @param width the width\n * @param pp the printer-parser, not null\n * @return this, for chaining, not null\n */\n _appendValuePrinterParser(pp) {\n assert(pp != null);\n if (this._active._valueParserIndex >= 0 &&\n this._active._printerParsers[this._active._valueParserIndex] instanceof NumberPrinterParser) {\n var activeValueParser = this._active._valueParserIndex;\n\n // adjacent parsing mode, update setting in previous parsers\n var basePP = this._active._printerParsers[activeValueParser];\n if (pp.minWidth() === pp.maxWidth() && pp.signStyle() === SignStyle.NOT_NEGATIVE) {\n // Append the width to the subsequentWidth of the active parser\n basePP = basePP.withSubsequentWidth(pp.maxWidth());\n // Append the new parser as a fixed width\n this._appendInternal(pp.withFixedWidth());\n // Retain the previous active parser\n this._active._valueParserIndex = activeValueParser;\n } else {\n // Modify the active parser to be fixed width\n basePP = basePP.withFixedWidth();\n // The new parser becomes the mew active parser\n this._active._valueParserIndex = this._appendInternal(pp);\n }\n // Replace the modified parser with the updated one\n this._active._printerParsers[activeValueParser] = basePP;\n } else {\n // The new Parser becomes the active parser\n this._active._valueParserIndex = this._appendInternal(pp);\n }\n return this;\n }\n\n /**\n * Appends a printer and/or parser to the internal list handling padding.\n *\n * @param pp the printer-parser to add, not null\n * @return the index into the active parsers list\n */\n _appendInternal(pp) {\n assert(pp != null);\n if (this._active._padNextWidth > 0) {\n if (pp != null) {\n pp = new PadPrinterParserDecorator(pp, this._active._padNextWidth, this._active._padNextChar);\n }\n this._active._padNextWidth = 0;\n this._active._padNextChar = 0;\n }\n this._active._printerParsers.push(pp);\n this._active._valueParserIndex = -1;\n return this._active._printerParsers.length - 1;\n }\n\n /**\n * Appends a string literal to the formatter.\n * \n * This string will be output during a print.\n * \n * If the literal is empty, nothing is added to the formatter.\n *\n * @param literal the literal to append, not null\n * @return this, for chaining, not null\n */\n appendLiteral(literal) {\n assert(literal != null);\n this._appendInternalPrinterParser(new StringLiteralPrinterParser(literal));\n return this;\n }\n \n /**\n * Appends a printer and/or parser to the internal list handling padding.\n *\n * @param pp the printer-parser to add, not null\n * @return the index into the active parsers list\n */\n _appendInternalPrinterParser(pp) {\n assert(pp != null);\n if (this._active._padNextWidth > 0) {\n if (pp != null) {\n pp = new PadPrinterParserDecorator(pp, this._active._padNextWidth, this._active._padNextChar);\n }\n this._active._padNextWidth = 0;\n this._active._padNextChar = 0;\n }\n this._active._printerParsers.push(pp);\n this._active._valueParserIndex = -1;\n return this._active._printerParsers.length - 1;\n }\n \n /**\n * Completes this builder by creating the DateTimeFormatter.\n * \n * This will create a formatter with the specified locale.\n * Numbers will be printed and parsed using the standard non-localized set of symbols.\n * \n * Calling this method will end any open optional sections by repeatedly\n * calling {@link #optionalEnd()} before creating the formatter.\n * \n * This builder can still be used after creating the formatter if desired,\n * although the state may have been changed by calls to {@code optionalEnd}.\n *\n * @param resolverStyle the new resolver style\n * @return the created formatter, not null\n */\n toFormatter(resolverStyle=ResolverStyle.SMART) {\n while (this._active._parent != null) {\n this.optionalEnd();\n }\n var pp = new CompositePrinterParser(this._printerParsers, false);\n return new DateTimeFormatter(pp, null, DecimalStyle.STANDARD, resolverStyle, null, null, null);\n }\n\n}\n\nconst EXCEED_POINTS = [\n 0,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n];\n\nclass CompositePrinterParser {\n\n constructor(printerParsers, optional) {\n this._printerParsers = printerParsers;\n this._optional = optional;\n }\n\n /**\n * Returns a copy of this printer-parser with the optional flag changed.\n *\n * @param optional the optional flag to set in the copy\n * @return the new printer-parser, not null\n */\n withOptional(optional) {\n if (optional === this._optional) {\n return this;\n }\n return new CompositePrinterParser(this._printerParsers, optional);\n }\n\n print(context, buf) {\n var length = buf.length();\n if (this._optional) {\n context.startOptional();\n }\n try {\n for (let i=0; i \n * {@code Month} is representing the 12 months of the year -\n * January, February, March, April, May, June, July, August, September, October,\n * November and December.\n * \n * In addition to the textual name, each month-of-year has an {@code int} value.\n * The {@code int} value follows normal usage and the ISO-8601 standard,\n * from 1 (January) to 12 (December). It is recommended that applications use the static values defined by this class\n * rather than the {@code int} value to ensure code clarity.\n * \n * This class represents a common concept that is found in many calendar systems.\n * As such, this class may be used by any calendar system that has the month-of-year\n * concept defined exactly equivalent to the ISO-8601 calendar system.\n *\n */\nexport class Month extends TemporalAccessor {\n \n /**\n *\n * @param {number} value\n */\n constructor(value) {\n super();\n this._value = value;\n }\n\n /**\n *\n * @return {number} gets the value\n */\n value() {\n return this._value;\n }\n \n /**\n * Checks if the specified field is supported.\n * \n * This checks if this month-of-year can be queried for the specified field.\n * If false, then calling the {@link #range(TemporalField) range} and\n * {@link #get(TemporalField) get} methods will throw an exception.\n * \n * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then\n * this method returns true.\n * All other {@code ChronoField} instances will return false.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}\n * passing {@code this} as the argument.\n * Whether the field is supported is determined by the field.\n *\n * @param {TemporalField} field the field to check, null returns false\n * @return {boolean} true if the field is supported on this month-of-year, false if not\n */\n isSupported(field) {\n if (null === field) {\n return false;\n }\n if (field instanceof ChronoField) {\n return field === ChronoField.MONTH_OF_YEAR;\n }\n return field != null && field.isSupportedBy(this);\n }\n\n /**\n * Gets the value of the specified field from this month-of-year as an {@code int}.\n * \n * This queries this month for the value of the specified field.\n * The returned value will always be within the valid range of values for the field.\n * If it is not possible to return the value, because the field is not supported\n * or for some other reason, an exception is thrown.\n * \n * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the\n * value of the month-of-year, from 1 to 12, will be returned.\n * All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}\n * passing {@code this} as the argument. Whether the value can be obtained,\n * and what the value represents, is determined by the field.\n *\n * @param {TemporalField} field the field to get, not null\n * @return {Number} the value for the field, within the valid range of values\n * @throws DateTimeException if a value for the field cannot be obtained or\n * the value is outside the range of valid values for the field\n * @throws UnsupportedTemporalTypeException if the field is not supported or\n * the range of values exceeds an {@code int}\n * @throws ArithmeticException if numeric overflow occurs\n */\n get(field) {\n if (field === ChronoField.MONTH_OF_YEAR) {\n return this.value();\n }\n return this.range(field).checkValidIntValue(this.getLong(field), field);\n }\n\n /**\n * Gets the value of the specified field from this month-of-year as a {@code long}.\n * \n * This queries this month for the value of the specified field.\n * If it is not possible to return the value, because the field is not supported\n * or for some other reason, an exception is thrown.\n * \n * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the\n * value of the month-of-year, from 1 to 12, will be returned.\n * All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.\n * \n * If the field is not a {@code ChronoField}, then the result of this method\n * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}\n * passing {@code this} as the argument. Whether the value can be obtained,\n * and what the value represents, is determined by the field.\n *\n * @param {TemporalField} field the field to get, not null\n * @return {Number} the value for the field\n * @throws DateTimeException if a value for the field cannot be obtained\n * @throws UnsupportedTemporalTypeException if the field is not supported\n * @throws ArithmeticException if numeric overflow occurs\n */\n getLong(field) {\n if (field === ChronoField.MONTH_OF_YEAR) {\n return this.value();\n } else if (field instanceof ChronoField) {\n throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);\n }\n return field.getFrom(this);\n }\n \n /**\n * Returns the month-of-year that is the specified number of months after this one.\n * \n * The calculation rolls around the end of the year from December to January.\n * The specified period may be negative.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {number} months the months to add, positive or negative\n * @return {Month} the resulting month, not null\n */\n plus(months) {\n var amount = Math.floor((months % 12)) + 12; // + 12 to make sure negative arguments are positive, the total is \"corrected\" by the next % 12\n var newMonthVal = ((this.value() + amount) % 12);\n /* December is 12, not 0, but 12 % 12 = 0 */\n newMonthVal = newMonthVal === 0 ? 12 : newMonthVal;\n return Month.of(newMonthVal);\n }\n\n /**\n * Returns the month-of-year that is the specified number of months before this one.\n * \n * The calculation rolls around the start of the year from January to December.\n * The specified period may be negative.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param {number} months the months to subtract, positive or negative\n * @return {Month} the resulting month, not null\n */\n minus(months) {\n return this.plus(-(months % 12));\n }\n\n /**\n * Gets the length of this month in days.\n * \n * This takes a flag to determine whether to return the length for a leap year or not.\n * \n * February has 28 days in a standard year and 29 days in a leap year.\n * April, June, September and November have 30 days.\n * All other months have 31 days.\n *\n * @param {boolean} leapYear true if the length is required for a leap year\n * @return {number} the length of this month in days, from 28 to 31\n */\n length(leapYear) {\n switch (this) {\n case Month.FEBRUARY:\n return (leapYear ? 29 : 28);\n case Month.APRIL:\n case Month.JUNE:\n case Month.SEPTEMBER:\n case Month.NOVEMBER:\n return 30;\n default:\n return 31;\n }\n }\n\n /**\n * Gets the minimum length of this month in days.\n * \n * February has a minimum length of 28 days.\n * April, June, September and November have 30 days.\n * All other months have 31 days.\n *\n * @return {number} the minimum length of this month in days, from 28 to 31\n */\n minLength() {\n switch (this) {\n case Month.FEBRUARY:\n return 28;\n case Month.APRIL:\n case Month.JUNE:\n case Month.SEPTEMBER:\n case Month.NOVEMBER:\n return 30;\n default:\n return 31;\n }\n }\n\n /**\n * Gets the maximum length of this month in days.\n * \n * February has a maximum length of 29 days.\n * April, June, September and November have 30 days.\n * All other months have 31 days.\n *\n * @return {number} the maximum length of this month in days, from 29 to 31\n */\n maxLength() {\n switch (this) {\n case Month.FEBRUARY:\n return 29;\n case Month.APRIL:\n case Month.JUNE:\n case Month.SEPTEMBER:\n case Month.NOVEMBER:\n return 30;\n default:\n return 31;\n }\n }\n\n /**\n * Gets the day-of-year corresponding to the first day of this month.\n * \n * This returns the day-of-year that this month begins on, using the leap\n * year flag to determine the length of February.\n *\n * @param {boolean} leapYear true if the length is required for a leap year\n * @return {number} the day of year corresponding to the first day of this month, from 1 to 336\n */\n firstDayOfYear(leapYear) {\n var leap = leapYear ? 1 : 0;\n switch (this) {\n case Month.JANUARY:\n return 1;\n case Month.FEBRUARY:\n return 32;\n case Month.MARCH:\n return 60 + leap;\n case Month.APRIL:\n return 91 + leap;\n case Month.MAY:\n return 121 + leap;\n case Month.JUNE:\n return 152 + leap;\n case Month.JULY:\n return 182 + leap;\n case Month.AUGUST:\n return 213 + leap;\n case Month.SEPTEMBER:\n return 244 + leap;\n case Month.OCTOBER:\n return 274 + leap;\n case Month.NOVEMBER:\n return 305 + leap;\n case Month.DECEMBER:\n default:\n return 335 + leap;\n }\n }\n\n /**\n * Gets the month corresponding to the first month of this quarter.\n * \n * The year can be divided into four quarters.\n * This method returns the first month of the quarter for the base month.\n * January, February and March return January.\n * April, May and June return April.\n * July, August and September return July.\n * October, November and December return October.\n *\n * @return {Month} the first month of the quarter corresponding to this month, not null\n */\n firstMonthOfQuarter() {\n switch (this) {\n case Month.JANUARY:\n case Month.FEBRUARY:\n case Month.MARCH:\n return Month.JANUARY;\n case Month.APRIL:\n case Month.MAY:\n case Month.JUNE:\n return Month.APRIL;\n case Month.JULY:\n case Month.AUGUST:\n case Month.SEPTEMBER:\n return Month.JULY;\n case Month.OCTOBER:\n case Month.NOVEMBER:\n case Month.DECEMBER:\n default:\n return Month.OCTOBER;\n }\n }\n \n /**\n * Queries this month-of-year using the specified query.\n * \n * This queries this month-of-year using the specified query strategy object.\n * The {@code TemporalQuery} object defines the logic to be used to\n * obtain the result. Read the documentation of the query to understand\n * what the result of this method will be.\n * \n * The result of this method is obtained by invoking the\n * {@link TemporalQuery#queryFrom(TemporalAccessor)} method on the\n * specified query passing {@code this} as the argument.\n *\n * @param {TemporalQuery} query the query to invoke, not null\n * @return the query result, null may be returned (defined by the query)\n * @throws DateTimeException if unable to query (defined by the query)\n * @throws ArithmeticException if numeric overflow occurs (defined by the query)\n */\n query(query) {\n assert(query != null, 'query() parameter must not be null', DateTimeException);\n if (query === TemporalQueries.chronology()) {\n return IsoChronology.INSTANCE;\n } else if (query === TemporalQueries.precision()) {\n return ChronoUnit.MONTHS;\n }\n return super.query(query);\n }\n\n\n\n /**\n * toString implementation... in JDK this is inherited from the Enum class\n * \n * @returns {String}\n */\n toString() {\n switch (this) {\n case Month.JANUARY:\n return 'JANUARY';\n case Month.FEBRUARY:\n return 'FEBRUARY';\n case Month.MARCH:\n return 'MARCH';\n case Month.APRIL:\n return 'APRIL';\n case Month.MAY:\n return 'MAY';\n case Month.JUNE:\n return 'JUNE';\n case Month.JULY:\n return 'JULY';\n case Month.AUGUST:\n return 'AUGUST';\n case Month.SEPTEMBER:\n return 'SEPTEMBER';\n case Month.OCTOBER:\n return 'OCTOBER';\n case Month.NOVEMBER:\n return 'NOVEMBER';\n case Month.DECEMBER:\n return 'DECEMBER';\n default:\n return 'unknown Month, value: ' + this.value();\n }\n }\n\n /**\n * replacement for enum values\n */\n static values(){\n return MONTHS.slice();\n }\n\n /**\n *\n * @param {number} month\n * @return {Month} not null\n **/\n static of(month) {\n if (month < 1 || month > 12) {\n assert(false, 'Invalid value for MonthOfYear: ' + month, DateTimeException);\n }\n return MONTHS[month-1];\n }\n}\n\nvar MONTHS;\n\nexport function _init() {\n Month.JANUARY = new Month(1);\n Month.FEBRUARY = new Month(2);\n Month.MARCH = new Month(3);\n Month.APRIL = new Month(4);\n Month.MAY = new Month(5);\n Month.JUNE = new Month(6);\n Month.JULY = new Month(7);\n Month.AUGUST = new Month(8);\n Month.SEPTEMBER = new Month(9);\n Month.OCTOBER = new Month(10);\n Month.NOVEMBER = new Month(11);\n Month.DECEMBER = new Month(12);\n\n MONTHS = [\n Month.JANUARY, Month.FEBRUARY, Month.MARCH, Month.APRIL, Month.MAY, Month.JUNE,\n Month.JULY, Month.AUGUST, Month.SEPTEMBER, Month.OCTOBER, Month.NOVEMBER, Month.DECEMBER\n ];\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/Month.js\n **/","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper \n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos \n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\n/**\n * A date-based amount of time, such as '2 years, 3 months and 4 days'.\n * \n * This class models a quantity or amount of time in terms of years, months and days.\n * See {@link Duration} for the time-based equivalent to this class.\n * \n * Durations and period differ in their treatment of daylight savings time\n * when added to {@link ZonedDateTime}. A {@code Duration} will add an exact\n * number of seconds, thus a duration of one day is always exactly 24 hours.\n * By contrast, a {@code Period} will add a conceptual day, trying to maintain\n * the local time.\n * \n * For example, consider adding a period of one day and a duration of one day to\n * 18:00 on the evening before a daylight savings gap. The {@code Period} will add\n * the conceptual day and result in a {@code ZonedDateTime} at 18:00 the following day.\n * By contrast, the {@code Duration} will add exactly 24 hours, resulting in a\n * {@code ZonedDateTime} at 19:00 the following day (assuming a one hour DST gap).\n * \n * The supported units of a period are {@link ChronoUnit#YEARS YEARS},\n * {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}.\n * All three fields are always present, but may be set to zero.\n * \n * The period may be used with any calendar system.\n * The meaning of a 'year' or 'month' is only applied when the object is added to a date.\n * \n * The period is modeled as a directed amount of time, meaning that individual parts of the\n * period may be negative.\n * \n * The months and years fields may be {@linkplain #normalized() normalized}.\n * The normalization assumes a 12 month year, so is not appropriate for all calendar systems.\n *\n * \n * The resulting period will have the specified years.\n * The months and days units will be zero.\n *\n * @param years the number of years, positive or negative\n * @return the period of years, not null\n */\n static ofYears(years) {\n return Period.create(years, 0, 0);\n }\n\n /**\n * Obtains a {@code Period} representing a number of months.\n * \n * The resulting period will have the specified months.\n * The years and days units will be zero.\n *\n * @param months the number of months, positive or negative\n * @return the period of months, not null\n */\n static ofMonths(months) {\n return Period.create(0, months, 0);\n }\n\n /**\n * Obtains a {@code Period} representing a number of weeks.\n * \n * The resulting period will have days equal to the weeks multiplied by seven.\n * The years and months units will be zero.\n *\n * @param weeks the number of weeks, positive or negative\n * @return the period of days, not null\n */\n static ofWeeks(weeks) {\n return Period.create(0, 0, MathUtil.safeMultiply(weeks, 7));\n }\n\n /**\n * Obtains a {@code Period} representing a number of days.\n * \n * The resulting period will have the specified days.\n * The years and months units will be zero.\n *\n * @param days the number of days, positive or negative\n * @return the period of days, not null\n */\n static ofDays(days) {\n return Period.create(0, 0, days);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains a {@code Period} representing a number of years, months and days.\n * \n * This creates an instance based on years, months and days.\n *\n * @param years the amount of years, may be negative\n * @param months the amount of months, may be negative\n * @param days the amount of days, may be negative\n * @return the period of years, months and days, not null\n */\n static of(years, months, days) {\n return Period.create(years, months, days);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains an instance of {@code Period} from a temporal amount.\n * \n * This obtains a period based on the specified amount.\n * A {@code TemporalAmount} represents an amount of time, which may be\n * date-based or time-based, which this factory extracts to a {@code Period}.\n * \n * The conversion loops around the set of units from the amount and uses\n * the {@link ChronoUnit#YEARS YEARS}, {@link ChronoUnit#MONTHS MONTHS}\n * and {@link ChronoUnit#DAYS DAYS} units to create a period.\n * If any other units are found then an exception is thrown.\n * \n * If the amount is a {@code ChronoPeriod} then it must use the ISO chronology.\n *\n * @param amount the temporal amount to convert, not null\n * @return the equivalent period, not null\n * @throws DateTimeException if unable to convert to a {@code Period}\n * @throws ArithmeticException if the amount of years, months or days exceeds an int\n */\n static from(amount) {\n if (amount instanceof Period) {\n return amount;\n }\n/*\n if (amount instanceof ChronoPeriod) {\n if (IsoChronology.INSTANCE !== amount.chronology()) {\n throw new DateTimeException('Period requires ISO chronology: ' + amount);\n }\n }\n*/\n requireNonNull(amount, 'amount');\n var years = 0;\n var months = 0;\n var days = 0;\n var units = amount.units();\n for (let i=0; i \n * The result of this method can be a negative period if the end is before the start.\n * The negative sign will be the same in each of year, month and day.\n *\n * @param startDate the start date, inclusive, not null\n * @param endDate the end date, exclusive, not null\n * @return the period between this date and the end date, not null\n * @see ChronoLocalDate#until(ChronoLocalDate)\n */\n static between(startDate, endDate) {\n requireNonNull(startDate, 'startDate');\n requireNonNull(endDate, 'endDate');\n requireInstance(startDate, LocalDate, 'startDate');\n requireInstance(endDate, LocalDate, 'endDate');\n return startDate.until(endDate);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains a {@code Period} from a text string such as {@code PnYnMnD}.\n * \n * This will parse the string produced by {@code toString()} which is\n * based on the ISO-8601 period formats {@code PnYnMnD} and {@code PnW}.\n * \n * The string starts with an optional sign, denoted by the ASCII negative\n * or positive symbol. If negative, the whole period is negated.\n * The ASCII letter 'P' is next in upper or lower case.\n * There are then four sections, each consisting of a number and a suffix.\n * At least one of the four sections must be present.\n * The sections have suffixes in ASCII of 'Y', 'M', 'W' and 'D' for\n * years, months, weeks and days, accepted in upper or lower case.\n * The suffixes must occur in order.\n * The number part of each section must consist of ASCII digits.\n * The number may be prefixed by the ASCII negative or positive symbol.\n * The number must parse to an {@code int}.\n * \n * The leading plus/minus sign, and negative values for other units are\n * not part of the ISO-8601 standard. In addition, ISO-8601 does not\n * permit mixing between the {@code PnYnMnD} and {@code PnW} formats.\n * Any week-based input is multiplied by 7 and treated as a number of days.\n * \n * For example, the following are valid inputs:\n * \n * A zero period has the value zero for the years, months and days units.\n *\n * @return true if this period is zero-length\n */\n isZero() {\n return (this === Period.ZERO);\n }\n\n /**\n * Checks if any of the three units of this period are negative.\n * \n * This checks whether the years, months or days units are less than zero.\n *\n * @return true if any unit of this period is negative\n */\n isNegative() {\n return this._years < 0 || this._months < 0 || this._days < 0;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Gets the amount of years of this period.\n * \n * This returns the years unit.\n * \n * The months unit is not normalized with the years unit.\n * This means that a period of '15 months' is different to a period\n * of '1 year and 3 months'.\n *\n * @return the amount of years of this period, may be negative\n */\n years() {\n return this._years;\n }\n\n /**\n * Gets the amount of months of this period.\n * \n * This returns the months unit.\n * \n * The months unit is not normalized with the years unit.\n * This means that a period of '15 months' is different to a period\n * of '1 year and 3 months'.\n *\n * @return the amount of months of this period, may be negative\n */\n months() {\n return this._months;\n }\n\n /**\n * Gets the amount of days of this period.\n * \n * This returns the days unit.\n *\n * @return the amount of days of this period, may be negative\n */\n days() {\n return this._days;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this period with the specified amount of years.\n * \n * This sets the amount of the years unit in a copy of this period.\n * The months and days units are unaffected.\n * \n * The months unit is not normalized with the years unit.\n * This means that a period of '15 months' is different to a period\n * of '1 year and 3 months'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param years the years to represent, may be negative\n * @return a {@code Period} based on this period with the requested years, not null\n */\n withYears(years) {\n if (years === this._years) {\n return this;\n }\n return Period.create(years, this._months, this._days);\n }\n\n /**\n * Returns a copy of this period with the specified amount of months.\n * \n * This sets the amount of the months unit in a copy of this period.\n * The years and days units are unaffected.\n * \n * The months unit is not normalized with the years unit.\n * This means that a period of '15 months' is different to a period\n * of '1 year and 3 months'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param months the months to represent, may be negative\n * @return a {@code Period} based on this period with the requested months, not null\n */\n withMonths(months) {\n if (months === this._months) {\n return this;\n }\n return Period.create(this._years, months, this._days);\n }\n\n /**\n * Returns a copy of this period with the specified amount of days.\n * \n * This sets the amount of the days unit in a copy of this period.\n * The years and months units are unaffected.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param days the days to represent, may be negative\n * @return a {@code Period} based on this period with the requested days, not null\n */\n withDays(days) {\n if (days === this._days) {\n return this;\n }\n return Period.create(this._years, this._months, days);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this period with the specified amount added.\n * \n * This input amount is converted to a {@code Period} using {@code from(TemporalAmount)}.\n * This operates separately on the years, months and days.\n * \n * For example, '1 year, 6 months and 3 days' plus '2 years, 2 months and 2 days'\n * returns '3 years, 8 months and 5 days'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amountToAdd the period to add, not null\n * @return a {@code Period} based on this period with the requested period added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plus(amountToAdd) {\n var amount = Period.from(amountToAdd);\n return Period.create(\n MathUtil.safeAdd(this._years, amount._years),\n MathUtil.safeAdd(this._months, amount._months),\n MathUtil.safeAdd(this._days, amount._days));\n }\n\n /**\n * Returns a copy of this period with the specified years added.\n * \n * This adds the amount to the years unit in a copy of this period.\n * The months and days units are unaffected.\n * For example, '1 year, 6 months and 3 days' plus 2 years returns '3 years, 6 months and 3 days'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param yearsToAdd the years to add, positive or negative\n * @return a {@code Period} based on this period with the specified years added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusYears(yearsToAdd) {\n if (yearsToAdd === 0) {\n return this;\n }\n return Period.create(MathUtil.safeToInt(MathUtil.safeAdd(this._years, yearsToAdd)), this._months, this._days);\n }\n\n /**\n * Returns a copy of this period with the specified months added.\n * \n * This adds the amount to the months unit in a copy of this period.\n * The years and days units are unaffected.\n * For example, '1 year, 6 months and 3 days' plus 2 months returns '1 year, 8 months and 3 days'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param monthsToAdd the months to add, positive or negative\n * @return a {@code Period} based on this period with the specified months added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusMonths(monthsToAdd) {\n if (monthsToAdd === 0) {\n return this;\n }\n return Period.create(this._years, MathUtil.safeToInt(MathUtil.safeAdd(this._months, monthsToAdd)), this._days);\n }\n\n /**\n * Returns a copy of this period with the specified days added.\n * \n * This adds the amount to the days unit in a copy of this period.\n * The years and months units are unaffected.\n * For example, '1 year, 6 months and 3 days' plus 2 days returns '1 year, 6 months and 5 days'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param daysToAdd the days to add, positive or negative\n * @return a {@code Period} based on this period with the specified days added, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n plusDays(daysToAdd) {\n if (daysToAdd === 0) {\n return this;\n }\n return Period.create(this._years, this._months, MathUtil.safeToInt(MathUtil.safeAdd(this._days, daysToAdd)));\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this period with the specified amount subtracted.\n * \n * This input amount is converted to a {@code Period} using {@code from(TemporalAmount)}.\n * This operates separately on the years, months and days.\n * \n * For example, '1 year, 6 months and 3 days' minus '2 years, 2 months and 2 days'\n * returns '-1 years, 4 months and 1 day'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param amountToSubtract the period to subtract, not null\n * @return a {@code Period} based on this period with the requested period subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minus(amountToSubtract) {\n var amount = Period.from(amountToSubtract);\n return Period.create(\n MathUtil.safeSubtract(this._years, amount._years),\n MathUtil.safeSubtract(this._months, amount._months),\n MathUtil.safeSubtract(this._days, amount._days));\n }\n\n /**\n * Returns a copy of this period with the specified years subtracted.\n * \n * This subtracts the amount from the years unit in a copy of this period.\n * The months and days units are unaffected.\n * For example, '1 year, 6 months and 3 days' minus 2 years returns '-1 years, 6 months and 3 days'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param yearsToSubtract the years to subtract, positive or negative\n * @return a {@code Period} based on this period with the specified years subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusYears(yearsToSubtract) {\n return this.plusYears(-1 * yearsToSubtract);\n }\n\n /**\n * Returns a copy of this period with the specified months subtracted.\n * \n * This subtracts the amount from the months unit in a copy of this period.\n * The years and days units are unaffected.\n * For example, '1 year, 6 months and 3 days' minus 2 months returns '1 year, 4 months and 3 days'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param monthsToSubtract the years to subtract, positive or negative\n * @return a {@code Period} based on this period with the specified months subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusMonths(monthsToSubtract) {\n return this.plusMonths(-1 * monthsToSubtract);\n }\n\n /**\n * Returns a copy of this period with the specified days subtracted.\n * \n * This subtracts the amount from the days unit in a copy of this period.\n * The years and months units are unaffected.\n * For example, '1 year, 6 months and 3 days' minus 2 days returns '1 year, 6 months and 1 day'.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param daysToSubtract the months to subtract, positive or negative\n * @return a {@code Period} based on this period with the specified days subtracted, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n minusDays(daysToSubtract) {\n return this.plusDays(-1 * daysToSubtract);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a new instance with each element in this period multiplied\n * by the specified scalar.\n * \n * This simply multiplies each field, years, months, days and normalized time,\n * by the scalar. No normalization is performed.\n *\n * @param scalar the scalar to multiply by, not null\n * @return a {@code Period} based on this period with the amounts multiplied by the scalar, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n multipliedBy(scalar) {\n if (this === Period.ZERO || scalar === 1) {\n return this;\n }\n return Period.create(\n MathUtil.safeMultiply(this._years, scalar),\n MathUtil.safeMultiply(this._months, scalar),\n MathUtil.safeMultiply(this._days, scalar));\n }\n\n /**\n * Returns a new instance with each amount in this period negated.\n *\n * @return a {@code Period} based on this period with the amounts negated, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n negated() {\n return this.multipliedBy(-1);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Returns a copy of this period with the years and months normalized\n * using a 12 month year.\n * \n * This normalizes the years and months units, leaving the days unit unchanged.\n * The months unit is adjusted to have an absolute value less than 11,\n * with the years unit being adjusted to compensate. For example, a period of\n * '1 Year and 15 months' will be normalized to '2 years and 3 months'.\n * \n * The sign of the years and months units will be the same after normalization.\n * For example, a period of '1 year and -25 months' will be normalized to\n * '-1 year and -1 month'.\n * \n * This normalization uses a 12 month year which is not valid for all calendar systems.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @return a {@code Period} based on this period with excess months normalized to years, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n normalized() {\n var totalMonths = this.toTotalMonths();\n var splitYears = MathUtil.intDiv(totalMonths, 12);\n var splitMonths = MathUtil.intMod(totalMonths, 12); // no overflow\n if (splitYears === this._years && splitMonths === this._months) {\n return this;\n }\n return Period.create(MathUtil.safeToInt(splitYears), splitMonths, this._days);\n }\n\n /**\n * Gets the total number of months in this period using a 12 month year.\n * \n * This returns the total number of months in the period by multiplying the\n * number of years by 12 and adding the number of months.\n * \n * This uses a 12 month year which is not valid for all calendar systems.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @return the total number of months in the period, may be negative\n */\n toTotalMonths() {\n return this._years * 12 + this._months; // no overflow\n }\n\n //-------------------------------------------------------------------------\n /**\n * Adds this period to the specified temporal object.\n * \n * This returns a temporal object of the same observable type as the input\n * with this period added.\n * \n * In most cases, it is clearer to reverse the calling pattern by using\n * {@link Temporal#plus(TemporalAmount)}.\n * \n * The calculation will add the years, then months, then days.\n * Only non-zero amounts will be added.\n * If the date-time has a calendar system with a fixed number of months in a\n * year, then the years and months will be combined before being added.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param temporal the temporal object to adjust, not null\n * @return an object of the same type with the adjustment made, not null\n * @throws DateTimeException if unable to add\n * @throws ArithmeticException if numeric overflow occurs\n */\n addTo(temporal) {\n requireNonNull(temporal, 'temporal');\n if (this._years !== 0) {\n if (this._months !== 0) {\n temporal = temporal.plus(this.toTotalMonths(), ChronoUnit.MONTHS);\n } else {\n temporal = temporal.plus(this._years, ChronoUnit.YEARS);\n }\n } else if (this._months !== 0) {\n temporal = temporal.plus(this._months, ChronoUnit.MONTHS);\n }\n if (this._days !== 0) {\n temporal = temporal.plus(this._days, ChronoUnit.DAYS);\n }\n return temporal;\n }\n\n /**\n * Subtracts this period from the specified temporal object.\n * \n * This returns a temporal object of the same observable type as the input\n * with this period subtracted.\n * \n * In most cases, it is clearer to reverse the calling pattern by using\n * {@link Temporal#minus(TemporalAmount)}.\n * \n * The calculation operates as follows.\n * First, the chronology of the temporal is checked to ensure it is ISO chronology or null.\n * Second, if the months are zero, the years are added if non-zero, otherwise\n * the combination of years and months is added if non-zero.\n * Finally, any days are added.\n * \n * The calculation will subtract the years, then months, then days.\n * Only non-zero amounts will be subtracted.\n * If the date-time has a calendar system with a fixed number of months in a\n * year, then the years and months will be combined before being subtracted.\n * \n * This instance is immutable and unaffected by this method call.\n *\n * @param temporal the temporal object to adjust, not null\n * @return an object of the same type with the adjustment made, not null\n * @throws DateTimeException if unable to subtract\n * @throws ArithmeticException if numeric overflow occurs\n */\n subtractFrom(temporal) {\n requireNonNull(temporal, 'temporal');\n if (this._years !== 0) {\n if (this._months !== 0) {\n temporal = temporal.minus(this.toTotalMonths(), ChronoUnit.MONTHS);\n } else {\n temporal = temporal.minus(this._years, ChronoUnit.YEARS);\n }\n } else if (this._months !== 0) {\n temporal = temporal.minus(this._months, ChronoUnit.MONTHS);\n }\n if (this._days !== 0) {\n temporal = temporal.minus(this._days, ChronoUnit.DAYS);\n }\n return temporal;\n }\n\n //-----------------------------------------------------------------------\n /**\n * Checks if this period is equal to another period.\n * \n * The comparison is based on the amounts held in the period.\n * To be equal, the years, months and days units must be individually equal.\n * Note that this means that a period of '15 Months' is not equal to a period\n * of '1 Year and 3 Months'.\n *\n * @param obj the object to check, null returns false\n * @return true if this is equal to the other period\n */\n equals(obj) {\n if (this === obj) {\n return true;\n }\n if (obj instanceof Period) {\n var other = obj;\n return this._years === other._years &&\n this._months === other._months &&\n this._days === other._days;\n }\n return false;\n }\n\n /**\n * A hash code for this period.\n *\n * @return a suitable hash code\n */\n hashCode() {\n return this._years + (this._months << 8) + (this._days << 16);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Outputs this period as a {@code String}, such as {@code P6Y3M1D}.\n * \n * The output will be in the ISO-8601 period format.\n * A zero period will be represented as zero days, 'P0D'.\n *\n * @return a string representation of this period, not null\n */\n toString() {\n if (this === Period.ZERO) {\n return 'P0D';\n } else {\n var buf = 'P';\n if (this._years !== 0) {\n buf += '' + this._years + 'Y';\n }\n if (this._months !== 0) {\n buf += '' + this._months + 'M';\n }\n if (this._days !== 0) {\n buf += '' + this._days + 'D';\n }\n return buf;\n }\n }\n}\n\nexport function _init() {\n /**\n * A constant for a period of zero.\n */\n Period.ZERO = makeZeroPeriod();\n\n function makeZeroPeriod() {\n var zero = Object.create(Period.prototype);\n TemporalAmount.call(zero);\n zero._years = 0;\n zero._months = 0;\n zero._days = 0;\n return zero;\n }\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/Period.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n/**\n * A year in the ISO-8601 calendar system, such as {@code 2007}.\n * \n * {@code Year} is an immutable date-time object that represents a year.\n * Any field that can be derived from a year can be obtained.\n * \n * Note that years in the ISO chronology only align with years in the\n * Gregorian-Julian system for modern years. Parts of Russia did not switch to the\n * modern Gregorian/ISO rules until 1920.\n * As such, historical years must be treated with caution.\n * \n * This class does not store or represent a month, day, time or time-zone.\n * For example, the value \"2007\" can be stored in a {@code Year}.\n * \n * Years represented by this class follow the ISO-8601 standard and use\n * the proleptic numbering system. Year 1 is preceded by year 0, then by year -1.\n * \n * The ISO-8601 calendar system is the modern civil calendar system used today\n * in most of the world. It is equivalent to the proleptic Gregorian calendar\n * system, in which today's rules for leap years are applied for all time.\n * For most applications written today, the ISO-8601 rules are entirely suitable.\n * However, any application that makes use of historical dates, and requires them\n * to be accurate will find the ISO-8601 approach unsuitable.\n *\n */\nexport class Year {\n \n}\n\nexport function _init() {\n /**\n * The minimum supported year\n */\n Year.MIN_VALUE = -999999;\n /**\n * The maximum supported year\n */\n Year.MAX_VALUE = 999999;\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/Year.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nexport class TemporalField {\n constructor() {\n \n }\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/temporal/TemporalField.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {assert} from '../assert';\nimport {DateTimeException} from '../errors';\nimport {MathUtil} from '../MathUtil';\n\n/**\n * The range of valid values for a date-time field.\n * \n * All TemporalField instances have a valid range of values.\n * For example, the ISO day-of-month runs from 1 to somewhere between 28 and 31.\n * This class captures that valid range.\n * \n * It is important to be aware of the limitations of this class.\n * Only the minimum and maximum values are provided.\n * It is possible for there to be invalid values within the outer range.\n * For example, a weird field may have valid values of 1, 2, 4, 6, 7, thus\n * have a range of '1 - 7', despite that fact that values 3 and 5 are invalid.\n * \n * Instances of this class are not tied to a specific field.\n *\n */\n\nexport class ValueRange {\n\n constructor(minSmallest, minLargest, maxSmallest, maxLargest) {\n assert(!(minSmallest > minLargest), 'Smallest minimum value \\'' + minSmallest +\n '\\' must be less than largest minimum value \\'' + minLargest + '\\'');\n assert(!(maxSmallest > maxLargest), 'Smallest maximum value \\'' + maxSmallest +\n '\\' must be less than largest maximum value \\'' + maxLargest + '\\'');\n assert(!(minLargest > maxLargest), 'Minimum value \\'' + minLargest +\n '\\' must be less than maximum value \\'' + maxLargest + '\\'');\n\n this._minSmallest = minSmallest;\n this._minLargest = minLargest;\n this._maxLargest = maxLargest;\n this._maxSmallest = maxSmallest;\n }\n\n minimum(){\n return this._minSmallest;\n }\n\n largestMinimum(){\n return this._minLargest;\n }\n\n maximum(){\n return this._maxLargest;\n }\n\n smallestMaximum(){\n return this._maxSmallest;\n }\n\n isValidValue(value) {\n return (this.minimum() <= value && value <= this.maximum());\n }\n\n checkValidValue(value, field) {\n var msg;\n if (!this.isValidValue(value)) {\n if (field != null) {\n msg = ('Invalid value for ' + field + ' (valid values ' + (this.toString()) + '): ') + value;\n } else {\n msg = ('Invalid value (valid values ' + (this.toString()) + '): ') + value;\n }\n return assert(false, msg, DateTimeException);\n }\n }\n\n /**\n * Checks that the specified value is valid and fits in an {@code int}.\n * \n * This validates that the value is within the valid range of values and that\n * all valid values are within the bounds of an {@code int}.\n * The field is only used to improve the error message.\n *\n * @param value the value to check\n * @param field the field being checked, may be null\n * @return the value that was passed in\n * @see #isValidIntValue(long)\n */\n checkValidIntValue(value, field) {\n if (this.isValidIntValue(value) === false) {\n throw new DateTimeException('Invalid int value for ' + field + ': ' + value);\n }\n return value;\n }\n\n /**\n * Checks if the value is within the valid range and that all values\n * in the range fit in an {@code int}.\n * \n * This method combines {@link #isIntValue()} and {@link #isValidValue(long)}.\n *\n * @param value the value to check\n * @return true if the value is valid and fits in an {@code int}\n */\n isValidIntValue(value) {\n return this.isIntValue() && this.isValidValue(value);\n }\n\n /**\n * Checks if all values in the range fit in an {@code int}.\n * \n * This checks that all valid values are within the bounds of an {@code int}.\n * \n * For example, the ISO month-of-year has values from 1 to 12, which fits in an {@code int}.\n * By comparison, ISO nano-of-day runs from 1 to 86,400,000,000,000 which does not fit in an {@code int}.\n * \n * This implementation uses {@link #getMinimum()} and {@link #getMaximum()}.\n *\n * @return boolean if a valid value always fits in an {@code int}\n */\n isIntValue() {\n return this.minimum() >= MathUtil.MIN_SAFE_INTEGER && this.maximum() <= MathUtil.MAX_SAFE_INTEGER;\n }\n\n /*\n * Outputs this range as a String.\n * \n * The format will be '{min}/{largestMin} - {smallestMax}/{max}',\n * where the largestMin or smallestMax sections may be omitted, together\n * with associated slash, if they are the same as the min or max.\n *\n * @return {string} a string representation of this range, not null\n */\n\n toString() {\n var str = this.minimum() + (this.minimum() !== this.largestMinimum() ? '/' + (this.largestMinimum()) : '');\n str += ' - ';\n str += this.smallestMaximum() + (this.smallestMaximum() !== this.maximum() ? '/' + (this.maximum()) : '');\n return str;\n }\n\n /*\n * called with 2 params: Obtains a fixed value range.\n *\n * This factory obtains a range where the minimum and maximum values are fixed.\n * For example, the ISO month-of-year always runs from 1 to 12.\n *\n * @param min the minimum value\n * @param max the maximum value\n * @return the ValueRange for min, max, not null\n\n * called with 3 params: Obtains a variable value range.\n *\n * This factory obtains a range where the minimum value is fixed and the maximum value may vary.\n * For example, the ISO day-of-month always starts at 1, but ends between 28 and 31.\n *\n * @param min the minimum value\n * @param maxSmallest the smallest maximum value\n * @param maxLargest the largest maximum value\n * @return the ValueRange for min, smallest max, largest max, not null\n\n * called with 4 params: Obtains a fully variable value range.\n *\n * This factory obtains a range where both the minimum and maximum value may vary.\n *\n * @param minSmallest the smallest minimum value\n * @param minLargest the largest minimum value\n * @param maxSmallest the smallest maximum value\n * @param maxLargest the largest maximum value\n * @return {ValueRange} the ValueRange for smallest min, largest min, smallest max, largest max, not null\n */\n\n static of() {\n if (arguments.length === 2) {\n return new ValueRange(arguments[0], arguments[0], arguments[1], arguments[1]);\n } else if (arguments.length === 3) {\n return new ValueRange(arguments[0], arguments[0], arguments[1], arguments[2]);\n } else if (arguments.length === 4) {\n return new ValueRange(arguments[0], arguments[1], arguments[2], arguments[3]);\n } else {\n return assert(false, 'Invalid number of arguments ' + arguments.length);\n }\n }\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/temporal/ValueRange.js\n **/","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport {_init as DayOfWeekInit} from './DayOfWeek';\nimport {_init as DurationInit} from './Duration';\nimport {_init as InstantInit} from './Instant';\nimport {_init as LocalDateInit} from './LocalDate';\nimport {_init as LocalTimeInit} from './LocalTime';\nimport {_init as MonthInit} from './Month';\nimport {_init as PeriodInit} from './Period';\nimport {_init as YearInit} from './Year';\nimport {_init as ZoneOffsetInit} from './ZoneOffset';\nimport {_init as IsoChronologyInit} from './chrono/IsoChronology';\nimport {_init as DateTimeFormatterInit} from './format/DateTimeFormatter';\nimport {_init as ChronoFieldInit} from './temporal/ChronoField';\nimport {_init as ChronoUnitInit} from './temporal/ChronoUnit';\nimport {_init as TemporalQueriesInit} from './temporal/TemporalQueries';\n\nvar isInit = false;\n\nfunction init() {\n\n if (isInit) {\n return;\n }\n\n isInit = true;\n\n YearInit();\n DurationInit();\n LocalTimeInit();\n ChronoUnitInit();\n ChronoFieldInit();\n TemporalQueriesInit();\n DayOfWeekInit();\n InstantInit();\n LocalDateInit();\n MonthInit();\n PeriodInit();\n ZoneOffsetInit();\n IsoChronologyInit();\n DateTimeFormatterInit();\n}\n\ninit();\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/_init.js\n **/"],"sourceRoot":""}\n * Duration.ofSeconds(3, 1);\n * Duration.ofSeconds(4, -999_999_999);\n * Duration.ofSeconds(2, 1000_000_001);\n *
\n *\n * @param {Number} seconds the number of seconds, positive or negative\n * @param {Number} nanoAdjustment the nanosecond adjustment to the number of seconds, positive or negative\n * @return {@code Duration}, not null\n * @throws ArithmeticException if the adjustment causes the seconds to exceed the capacity of {@code Duration}\n */\n static ofSeconds(seconds, nanoAdjustment = 0) {\n var secs = MathUtil.safeAdd(seconds, MathUtil.floorDiv(nanoAdjustment, LocalTime.NANOS_PER_SECOND));\n var nos = MathUtil.floorMod(nanoAdjustment, LocalTime.NANOS_PER_SECOND);\n return Duration.create(secs, nos);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains an instance of {@code Duration} from a number of milliseconds.\n * \n * Duration.of(3, SECONDS);\n * Duration.of(465, HOURS);\n *
\n * Only a subset of units are accepted by this method.\n * The unit must either have an {@link TemporalUnit#isDurationEstimated() exact duration} or\n * be {@link ChronoUnit#DAYS} which is treated as 24 hours. Other units throw an exception.\n *\n * @param {Number} amount the amount of the duration, measured in terms of the unit, positive or negative\n * @param {TemporalUnit} unit the unit that the duration is measured in, must have an exact duration, not null\n * @return {@code Duration}, not null\n * @throws DateTimeException if the period unit has an estimated duration\n * @throws ArithmeticException if a numeric overflow occurs\n */\n static of(amount, unit) {\n return Duration.ZERO.plus(amount, unit);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains an instance of {@code Duration} from an amount.\n * \n * \"PT20.345S\" -> parses as \"20.345 seconds\"\n * \"PT15M\" -> parses as \"15 minutes\" (where a minute is 60 seconds)\n * \"PT10H\" -> parses as \"10 hours\" (where an hour is 3600 seconds)\n * \"P2D\" -> parses as \"2 days\" (where a day is 24 hours or 86400 seconds)\n * \"P2DT3H4M\" -> parses as \"2 days, 3 hours and 4 minutes\"\n * \"P-6H3M\" -> parses as \"-6 hours and +3 minutes\"\n * \"-P6H3M\" -> parses as \"-6 hours and -3 minutes\"\n * \"-P-6H+3M\" -> parses as \"+6 hours and -3 minutes\"\n *
\n *\n * @param {String} text the text to parse, not null\n * @return {Duration} the parsed duration, not null\n * @throws DateTimeParseException if the text cannot be parsed to a duration\n */\n static parse(text) {\n requireNonNull(text, 'text');\n /**\n * The pattern for parsing.\n */\n const PATTERN = new RegExp('([-+]?)P(?:([-+]?[0-9]+)D)?(T(?:([-+]?[0-9]+)H)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)(?:[.,]([0-9]{0,9}))?S)?)?', 'i');\n var matches = PATTERN.exec(text);\n if (matches !== null) {\n // check for letter T but no time sections\n if ('T' === matches[3] === false) {\n var negate = '-' === matches[1];\n var dayMatch = matches[2];\n var hourMatch = matches[4];\n var minuteMatch = matches[5];\n var secondMatch = matches[6];\n var fractionMatch = matches[7];\n if (dayMatch != null || hourMatch != null || minuteMatch != null || secondMatch != null) {\n var daysAsSecs = Duration._parseNumber(text, dayMatch, LocalTime.SECONDS_PER_DAY, 'days');\n var hoursAsSecs = Duration._parseNumber(text, hourMatch, LocalTime.SECONDS_PER_HOUR, 'hours');\n var minsAsSecs = Duration._parseNumber(text, minuteMatch, LocalTime.SECONDS_PER_MINUTE, 'minutes');\n var seconds = Duration._parseNumber(text, secondMatch, 1, 'seconds');\n var negativeSecs = secondMatch != null && secondMatch.charAt(0) === '-';\n var nanos = Duration._parseFraction(text, fractionMatch, negativeSecs ? -1 : 1);\n try {\n return Duration.create(negate, daysAsSecs, hoursAsSecs, minsAsSecs, seconds, nanos);\n } catch (ex) {\n throw new DateTimeParseException('Text cannot be parsed to a Duration: overflow', text, 0, ex);\n }\n }\n }\n }\n throw new DateTimeParseException('Text cannot be parsed to a Duration', text, 0);\n }\n\n static _parseNumber(text, parsed, multiplier, errorText) {\n // regex limits to [-+]?[0-9]+\n if (parsed == null) {\n return 0;\n }\n try {\n if (parsed[0] === '+') {\n parsed = parsed.substring(1);\n }\n var val = parseFloat(parsed);\n return MathUtil.safeMultiply(val, multiplier);\n } catch (ex) {\n throw new DateTimeParseException('Text cannot be parsed to a Duration: ' + errorText, text, 0, ex);\n }\n }\n\n static _parseFraction(text, parsed, negate) {\n // regex limits to [0-9]{0,9}\n if (parsed == null || parsed.length === 0) {\n return 0;\n }\n try {\n parsed = (parsed + '000000000').substring(0, 9);\n return parseFloat(parsed) * negate;\n } catch (ex) {\n throw new DateTimeParseException('Text cannot be parsed to a Duration: fraction', text, 0, ex);\n }\n }\n\n //-----------------------------------------------------------------------\n /**\n * to handle function overriding this function accepts any number of arguments, checks their type and delegates to the appropriate function\n *\n * @return {Duration}\n */\n static create() {\n if (arguments.length === 1) {\n return Duration.createSeconds(arguments[0]);\n } else if (arguments.length === 2) {\n return Duration.createSecondsNanos(arguments[0], arguments[1]);\n } else {\n return Duration.createNegateDaysHoursMinutesSecondsNanos(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);\n }\n }\n\n static createNegateDaysHoursMinutesSecondsNanos(negate, daysAsSecs, hoursAsSecs, minsAsSecs, secs, nanos) {\n var seconds = MathUtil.safeAdd(daysAsSecs, MathUtil.safeAdd(hoursAsSecs, MathUtil.safeAdd(minsAsSecs, secs)));\n if (negate) {\n return Duration.ofSeconds(seconds, nanos).negated();\n }\n return Duration.ofSeconds(seconds, nanos);\n }\n\n /**\n * Obtains an instance of {@code Duration} using seconds and nanoseconds.\n *\n * @param {Number} seconds the length of the duration in seconds, positive or negative\n * @param {Number} nanoAdjustment the nanosecond adjustment within the second, from 0 to 999,999,999\n */\n static createSecondsNanos(seconds = 0, nanoAdjustment = 0) {\n if ((seconds | nanoAdjustment) === 0) {\n return Duration.ZERO;\n }\n // if seconds is a float, we need to adjust the nanos from it as well\n if (seconds >= 0) {\n nanoAdjustment += seconds % 1 * LocalTime.NANOS_PER_SECOND;\n } else {\n nanoAdjustment -= seconds % 1 * LocalTime.NANOS_PER_SECOND;\n }\n seconds = Math.floor(seconds);\n nanoAdjustment = Math.round(nanoAdjustment);\n\n return new Duration(seconds, nanoAdjustment);\n }\n \n /**\n * Creates an instance of {@code Duration} from a number of seconds.\n *\n * @param {Number} seconds the number of seconds, up to scale 9, positive or negative\n * @return {Duration}, not null\n * @throws ArithmeticException if numeric overflow occurs\n */\n static createSeconds(seconds) {\n let nanos = Math.round(seconds * Math.pow(10, 9));\n let div = MathUtil.intDiv(nanos, LocalTime.NANOS_PER_SECOND);\n let rem = MathUtil.intMod(nanos, LocalTime.NANOS_PER_SECOND);\n return Duration.ofSeconds(div, rem);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Gets the value of the requested unit.\n * \n * // these two lines are equivalent, but the second approach is recommended\n * dateTime = thisDuration.addTo(dateTime);\n * dateTime = dateTime.plus(thisDuration);\n *
\n * \n * // these two lines are equivalent, but the second approach is recommended\n * dateTime = thisDuration.subtractFrom(dateTime);\n * dateTime = dateTime.minus(thisDuration);\n *
\n * \n * \"20.345 seconds\" -> \"PT20.345S\n * \"15 minutes\" (15 * 60 seconds) -> \"PT15M\"\n * \"10 hours\" (10 * 3600 seconds) -> \"PT10H\"\n * \"2 days\" (2 * 86400 seconds) -> \"PT48H\"\n *
\n * Note that multiples of 24 hours are not output as days to avoid confusion\n * with {@code Period}.\n *\n * @return an ISO-8601 representation of this duration, not null\n */\n toString() {\n if (this === Duration.ZERO) {\n return 'PT0S';\n }\n var hours = MathUtil.intDiv(this._seconds, LocalTime.SECONDS_PER_HOUR);\n var minutes = MathUtil.intDiv(MathUtil.intMod(this._seconds, LocalTime.SECONDS_PER_HOUR), LocalTime.SECONDS_PER_MINUTE);\n var secs = MathUtil.intMod(this._seconds, LocalTime.SECONDS_PER_MINUTE);\n var rval = 'PT';\n if (hours !== 0) {\n rval += hours + 'H';\n }\n if (minutes !== 0) {\n rval += minutes + 'M';\n }\n if (secs === 0 && this._nanos === 0 && rval.length > 2) {\n return rval;\n }\n if (secs < 0 && this._nanos > 0) {\n if (secs === -1) {\n rval += '-0';\n } else {\n rval += secs + 1;\n }\n } else {\n rval += secs;\n }\n if (this._nanos > 0) {\n rval += '.';\n let nanoString;\n if (secs < 0) {\n nanoString = '' + (2 * LocalTime.NANOS_PER_SECOND - this._nanos);\n } else {\n nanoString = '' + (LocalTime.NANOS_PER_SECOND + this._nanos);\n }\n // remove the leading '1'\n nanoString = nanoString.slice(1, nanoString.length);\n rval += nanoString;\n while (rval.charAt(rval.length - 1) === '0') {\n rval = rval.slice(0, rval.length - 1);\n }\n }\n rval += 'S';\n return rval;\n }\n\n}\n\nexport function _init() {\n /**\n * Constant for a duration of zero.\n */\n Duration.ZERO = new Duration(0, 0);\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/Duration.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport {NullPointerException, IllegalArgumentException} from './errors';\n\nexport function assert(assertion, msg, error) {\n if(!assertion){\n if (error) {\n throw new error(msg);\n } else {\n throw new Error(msg);\n }\n }\n}\n\nexport function requireNonNull(value, parameterName) {\n if (value == null) {\n throw new NullPointerException(parameterName + ' must not be null');\n }\n return value;\n}\n\nexport function requireInstance(value, _class, parameterName) {\n if (!(value instanceof _class)) {\n throw new IllegalArgumentException(parameterName + ' must be an instance of ' + (_class.name ? _class.name : _class));\n }\n return value;\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/assert.js\n **/","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nexport class TemporalAmount{\n\n}\n\n\n/** WEBPACK FOOTER **\n ** ./src/temporal/TemporalAmount.js\n **/","/**\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\n\nimport {MathUtil} from './MathUtil';\nimport {assert, requireNonNull, requireInstance} from './assert';\nimport {DateTimeException, UnsupportedTemporalTypeException, IllegalArgumentException} from './errors';\n\nimport {Clock} from './Clock';\n\nimport {DateTimeFormatter} from './format/DateTimeFormatter';\n\nimport {ChronoField} from './temporal/ChronoField';\nimport {ChronoUnit} from './temporal/ChronoUnit';\nimport {TemporalAccessor} from './temporal/TemporalAccessor';\nimport {TemporalQueries, createTemporalQuery} from './temporal/TemporalQueries';\n\n/**\n * A time without time-zone in the ISO-8601 calendar system,\n * such as {@code 10:15:30}.\n * Specification for implementors
\n * This class is immutable and thread-safe.\n */\nexport class LocalTime extends TemporalAccessor /** implements Temporal, TemporalAdjuster */ {\n /**\n * Obtains the current time from the specified clock.\n * \n *
\n * All other {@code ChronoField} instances will return false.\n * \n *
\n * \n * // these two lines are equivalent, but the second approach is recommended\n * temporal = thisLocalTime.adjustInto(temporal);\n * temporal = temporal.with(thisLocalTime);\n *
\n * \n * long period = start.until(end, HOURS); // this method\n * dateTime.plus(HOURS.between(start, end)); // use in plus/minus\n *
\n * \n *
\n *
Specification for implementors
\n * This class is mutable and not thread-safe.\n * It should only be used from a single thread.\n */\nexport class DateTimeBuilder extends TemporalAccessor {\n constructor(){\n super();\n\n /**\n * The map of other fields.\n */\n this.fieldValues = new EnumMap();\n /**\n * The chronology.\n */\n this.chrono = null;\n /**\n * The zone.\n */\n this.zone = null;\n /**\n * The date.\n */\n this.date = null;\n /**\n * The time.\n */\n this.time = null;\n /**\n * The leap second flag.\n */\n this.leapSecond = false;\n /**\n * The excess days.\n */\n this.excessDays = null;\n }\n\n /**\n * Resolves the builder, evaluating the date and time.\n * \n *
\n * All other {@code ChronoField} instances will return false.\n * \n * import static org.threeten.bp.Month.*;\n * import static org.threeten.bp.temporal.Adjusters.*;\n *\n * result = localDate.with(JULY).with(lastDayOfMonth());\n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n * // these two lines are equivalent, but the second approach is recommended\n * temporal = thisLocalDate.adjustInto(temporal);\n * temporal = temporal.with(thisLocalDate);\n *
\n * \n * long period = start.until(end, MONTHS); // this method\n * dateTime.plus(MONTHS.between(start, end)); // use in plus/minus\n *
\n * \n * // these two lines are equivalent\n * period = start.until(end);\n * period = Period.between(start, end);\n *
\n * The choice should be made based on which makes the code more readable.\n *\n * @param endDate the end date, exclusive, which may be in any chronology, not null\n * @return the period between this date and the end date, not null\n */\n _until1(endDate) {\n var end = LocalDate.from(endDate);\n var totalMonths = end._prolepticMonth() - this._prolepticMonth(); // safe\n var days = end._day - this._day;\n if (totalMonths > 0 && days < 0) {\n totalMonths--;\n var calcDate = this.plusMonths(totalMonths);\n days = (end.toEpochDay() - calcDate.toEpochDay()); // safe\n } else if (totalMonths < 0 && days > 0) {\n totalMonths++;\n days -= end.lengthOfMonth();\n }\n var years = MathUtil.intDiv(totalMonths, 12); // safe\n var months = MathUtil.intMod(totalMonths, 12); // safe\n return Period.of(MathUtil.safeToInt(years), months, days);\n }\n\n\n /**\n * Converts this date to the Epoch Day.\n *\n * The Epoch Day count is a simple incrementing count of days where day 0 is 1970-01-01 (ISO).\n * This definition is the same for all chronologies, enabling conversion.\n *\n * @return {number} the Epoch Day equivalent to this date\n */\n toEpochDay() {\n var y = this.year();\n var m = this.monthValue();\n var total = 0;\n total += 365 * y;\n if (y >= 0) {\n total += MathUtil.intDiv(y + 3, 4) - MathUtil.intDiv(y + 99, 100) + MathUtil.intDiv(y + 399, 400);\n } else {\n total -= MathUtil.intDiv(y, -4) - MathUtil.intDiv(y, -100) + MathUtil.intDiv(y, -400);\n }\n total += MathUtil.intDiv(367 * m - 362, 12);\n total += this.dayOfMonth() - 1;\n if (m > 2) {\n total--;\n if (!IsoChronology.isLeapYear(y)) {\n total--;\n }\n }\n return total - DAYS_0000_TO_1970;\n }\n\n /**\n * Compares this date to another date.\n * \n * LocalDate a = LocalDate.of(2012, 6, 30);\n * LocalDate b = LocalDate.of(2012, 7, 1);\n * a.isAfter(b) == false\n * a.isAfter(a) == false\n * b.isAfter(a) == true\n *
\n * \n * LocalDate a = LocalDate.of(2012, 6, 30);\n * LocalDate b = LocalDate.of(2012, 7, 1);\n * a.isBefore(b) == true\n * a.isBefore(a) == false\n * b.isBefore(a) == false\n *
\n * \n * LocalDate a = LocalDate.of(2012, 6, 30);\n * LocalDate b = LocalDate.of(2012, 7, 1);\n * a.isEqual(b) == false\n * a.isEqual(a) == true\n * b.isEqual(a) == false\n *
\n * \n * // these two lines are equivalent, but the second approach is recommended\n * dateTime = query.queryFrom(dateTime);\n * dateTime = dateTime.query(query);\n *
\n * It is recommended to use the second approach, {@code query(TemporalQuery)},\n * as it is a lot clearer to read in code.\n *\n */\nexport class TemporalQueries {\n\n /**\n * A strict query for the {@code ZoneId}.\n *
\n * {@code LocalDate} returns null
\n * {@code LocalTime} returns null
\n * {@code LocalDateTime} returns null
\n * {@code ZonedDateTime} returns the associated zone
\n * {@code OffsetTime} returns null
\n * {@code OffsetDateTime} returns null
\n * {@code ChronoLocalDate} returns null
\n * {@code ChronoLocalDateTime} returns null
\n * {@code ChronoZonedDateTime} returns the associated zone
\n * {@code Era} returns null
\n * {@code DayOfWeek} returns null
\n * {@code Month} returns null
\n * {@code Year} returns null
\n * {@code YearMonth} returns null
\n * {@code MonthDay} returns null
\n * {@code ZoneOffset} returns null
\n * {@code Instant} returns null
\n *\n * @return a query that can obtain the zone ID of a temporal, not null\n */\n static zoneId() {\n return TemporalQueries.ZONE_ID;\n }\n\n /**\n * A query for the {@code Chronology}.\n *
\n * {@code LocalDate} returns {@code IsoChronology.INSTANCE}
\n * {@code LocalTime} returns null (does not represent a date)
\n * {@code LocalDateTime} returns {@code IsoChronology.INSTANCE}
\n * {@code ZonedDateTime} returns {@code IsoChronology.INSTANCE}
\n * {@code OffsetTime} returns null (does not represent a date)
\n * {@code OffsetDateTime} returns {@code IsoChronology.INSTANCE}
\n * {@code ChronoLocalDate} returns the associated chronology
\n * {@code ChronoLocalDateTime} returns the associated chronology
\n * {@code ChronoZonedDateTime} returns the associated chronology
\n * {@code Era} returns the associated chronology
\n * {@code DayOfWeek} returns null (shared across chronologies)
\n * {@code Month} returns {@code IsoChronology.INSTANCE}
\n * {@code Year} returns {@code IsoChronology.INSTANCE}
\n * {@code YearMonth} returns {@code IsoChronology.INSTANCE}
\n * {@code MonthDay} returns null {@code IsoChronology.INSTANCE}
\n * {@code ZoneOffset} returns null (does not represent a date)
\n * {@code Instant} returns null (does not represent a date)
\n *
\n * {@code LocalDate} returns {@code DAYS}
\n * {@code LocalTime} returns {@code NANOS}
\n * {@code LocalDateTime} returns {@code NANOS}
\n * {@code ZonedDateTime} returns {@code NANOS}
\n * {@code OffsetTime} returns {@code NANOS}
\n * {@code OffsetDateTime} returns {@code NANOS}
\n * {@code ChronoLocalDate} returns {@code DAYS}
\n * {@code ChronoLocalDateTime} returns {@code NANOS}
\n * {@code ChronoZonedDateTime} returns {@code NANOS}
\n * {@code Era} returns {@code ERAS}
\n * {@code DayOfWeek} returns {@code DAYS}
\n * {@code Month} returns {@code MONTHS}
\n * {@code Year} returns {@code YEARS}
\n * {@code YearMonth} returns {@code MONTHS}
\n * {@code MonthDay} returns null (does not represent a complete date or time)
\n * {@code ZoneOffset} returns null (does not represent a date or time)
\n * {@code Instant} returns {@code NANOS}
\n *\n * @return a query that can obtain the precision of a temporal, not null\n */\n static precision() {\n return TemporalQueries.PRECISION;\n }\n\n /**\n * A lenient query for the {@code ZoneId}, falling back to the {@code ZoneOffset}.\n * \n if (query == TemporalQueries.zoneId()\n || query == TemporalQueries.chronology()\n || query == TemporalQueries.precision()) {\n return null;\n }\n return query.queryFrom(this);\n *
\n *\n * @param {TemporalQuery} query the query to invoke, not null\n * @return the query result, null may be returned (defined by the query)\n * @throws DateTimeException if unable to query\n * @throws ArithmeticException if numeric overflow occurs\n */\n query(query) {\n if (query === TemporalQueries.zoneId()\n || query === TemporalQueries.chronology()\n || query === TemporalQueries.precision()) {\n return null;\n }\n return query.queryFrom(this);\n }\n \n /**\n * Gets the range of valid values for the specified field.\n * Specification for implementors
\n * Implementations must check and handle all fields defined in {@link ChronoField}.\n * If the field is supported, then the range of the field must be returned.\n * If unsupported, then a {@code DateTimeException} must be thrown.\n * \n * // these two lines are equivalent, but the second approach is recommended\n * temporal = thisDayOfWeek.adjustInto(temporal);\n * temporal = temporal.with(thisDayOfWeek);\n *
\n * \n * dateOnWed.with(MONDAY); // two days earlier\n * dateOnWed.with(TUESDAY); // one day earlier\n * dateOnWed.with(WEDNESDAY); // same date\n * dateOnWed.with(THURSDAY); // one day later\n * dateOnWed.with(FRIDAY); // two days later\n * dateOnWed.with(SATURDAY); // three days later\n * dateOnWed.with(SUNDAY); // four days later\n *
\n * Specification for implementors
\n * This class is immutable and thread-safe.\n */\n\nimport {MathUtil} from './MathUtil';\nimport {requireNonNull, requireInstance} from './assert';\nimport {DateTimeException, UnsupportedTemporalTypeException, ArithmeticException, DateTimeParseException} from './errors';\n\nimport {IsoChronology} from './chrono/IsoChronology';\n\nimport {ChronoUnit} from './temporal/ChronoUnit';\nimport {TemporalAmount} from './temporal/TemporalAmount';\n\nimport {LocalDate} from './LocalDate';\n\n/**\n * The pattern for parsing.\n */\nconst PATTERN = /([-+]?)P(?:([-+]?[0-9]+)Y)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)W)?(?:([-+]?[0-9]+)D)?/;\n\nexport class Period extends TemporalAmount /* extends ChronoPeriod */ {\n\n /**\n * do not call the constructor directly\n * use a factory method instead\n *\n * @param years\n * @param months\n * @param days\n * @private\n */\n constructor(years, months, days){\n super();\n if((years | months | days) === 0){\n return Period.ZERO;\n }\n Period._validate(years, months, days);\n /**\n * The number of years.\n */\n this._years = years;\n /**\n * The number of months.\n */\n this._months = months;\n /**\n * The number of days.\n */\n this._days = days;\n }\n\n static _validate(years, month, days){\n requireNonNull(years, 'years');\n requireNonNull(month, 'month');\n requireNonNull(days, 'days');\n MathUtil.safeToInt(years);\n MathUtil.safeToInt(month);\n MathUtil.safeToInt(days);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Obtains a {@code Period} representing a number of years.\n * \n * 'P2Y' -- Period.ofYears(2)\n * 'P3M' -- Period.ofMonths(3)\n * 'P4W' -- Period.ofWeeks(4)\n * 'P5D' -- Period.ofDays(5)\n * 'P1Y2M3D' -- Period.of(1, 2, 3)\n * 'P1Y2M3W4D' -- Period.of(1, 2, 25)\n * 'P-1Y2M' -- Period.of(-1, 2, 0)\n * '-P1Y2M' -- Period.of(-1, -2, 0)\n *
\n *\n * @param text the text to parse, not null\n * @return the parsed period, not null\n * @throws DateTimeParseException if the text cannot be parsed to a period\n */\n static parse(text) {\n requireNonNull(text, 'text');\n try {\n return Period._parse(text);\n } catch (ex){\n if(ex instanceof ArithmeticException){\n throw new DateTimeParseException('Text cannot be parsed to a Period', text, 0, ex);\n } else {\n throw ex;\n }\n }\n }\n\n /**\n * because functions that containing a try/ catch block cant be optimized,\n * we put the code in a sub function.\n */\n static _parse(text){\n var matches = PATTERN.exec(text);\n if (matches != null) {\n var negate = '-' === matches[1] ? -1 : 1;\n var yearMatch = matches[2];\n var monthMatch = matches[3];\n var weekMatch = matches[4];\n var dayMatch = matches[5];\n if (yearMatch != null || monthMatch != null || weekMatch != null || dayMatch != null) {\n var years = Period._parseNumber(text, yearMatch, negate);\n var months = Period._parseNumber(text, monthMatch, negate);\n var weeks = Period._parseNumber(text, weekMatch, negate);\n var days = Period._parseNumber(text, dayMatch, negate);\n days = MathUtil.safeAdd(days, MathUtil.safeMultiply(weeks, 7));\n return Period.create(years, months, days);\n }\n }\n throw new DateTimeParseException('Text cannot be parsed to a Period', text, 0);\n }\n\n static _parseNumber(text, str, negate) {\n if (str == null) {\n return 0;\n }\n var val = MathUtil.parseInt(str);\n return MathUtil.safeMultiply(val, negate);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Creates an instance.\n *\n * @param years the amount\n * @param months the amount\n * @param days the amount\n */\n static create(years, months, days) {\n return new Period(years, months, days);\n }\n\n //-----------------------------------------------------------------------\n units() {\n return [ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS];\n }\n\n chronology() {\n return IsoChronology.INSTANCE;\n }\n\n get(unit) {\n if (unit === ChronoUnit.YEARS) {\n return this._years;\n }\n if (unit === ChronoUnit.MONTHS) {\n return this._months;\n }\n if (unit === ChronoUnit.DAYS) {\n return this._days;\n }\n throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);\n }\n\n //-----------------------------------------------------------------------\n /**\n * Checks if all three units of this period are zero.\n * \n * // these two lines are equivalent, but the second approach is recommended\n * dateTime = thisPeriod.addTo(dateTime);\n * dateTime = dateTime.plus(thisPeriod);\n *
\n * \n * // these two lines are equivalent, but the second approach is recommended\n * dateTime = thisPeriod.subtractFrom(dateTime);\n * dateTime = dateTime.minus(thisPeriod);\n *
\n *