@attocash/cli 0.1.0

package/node_modules/@js-joda/core/src/temporal/TemporalUnit.js

@@ -0,0 +1,179 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {abstractMethodFail} from '../assert';
+
+/**
+ * A unit of date-time, such as Days or Hours.
+ *
+ * Measurement of time is built on units, such as years, months, days, hours, minutes and seconds.
+ * Implementations of this interface represent those units.
+ *
+ * An instance of this interface represents the unit itself, rather than an amount of the unit.
+ * See {@link Period} for a class that represents an amount in terms of the common units.
+ *
+ * The most commonly used units are defined in {@link ChronoUnit}.
+ * Further units are supplied in {@link IsoFields}.
+ * Units can also be written by application code by implementing this interface.
+ *
+ * The unit works using double dispatch. Client code calls methods on a date-time like
+ * {@link LocalDateTime} which check if the unit is a {@link ChronoUnit}.
+ * If it is, then the date-time must handle it.
+ * Otherwise, the method call is re-dispatched to the matching method in this interface.
+ *
+ * @interface
+ */
+export class TemporalUnit {
+    /**
+     * Gets the duration of this unit, which may be an estimate.
+     *
+     * All units return a duration measured in standard nanoseconds from this method.
+     * The duration will be positive and non-zero.
+     * For example, an hour has a duration of `60 * 60 * 1,000,000,000 ns`.
+     *
+     * Some units may return an accurate duration while others return an estimate.
+     * For example, days have an estimated duration due to the possibility of
+     * daylight saving time changes.
+     * To determine if the duration is an estimate, use {@link isDurationEstimated}.
+     *
+     * @return {Duration} the duration of this unit, which may be an estimate.
+     */
+    duration() {
+        abstractMethodFail('duration');
+    }
+
+    /**
+     * Checks if the duration of the unit is an estimate.
+     *
+     * All units have a duration, however the duration is not always accurate.
+     * For example, days have an estimated duration due to the possibility of
+     * daylight saving time changes.
+     * This method returns true if the duration is an estimate and false if it is
+     * accurate. Note that accurate/estimated ignores leap seconds.
+     *
+     * @return {boolean} `true` if the duration is estimated, `false` if accurate.
+     */
+    isDurationEstimated() {
+        abstractMethodFail('isDurationEstimated');
+    }
+
+    /**
+     * Checks if this unit is date-based.
+     *
+     * @return {boolean} `true` if date unit, `false` if a time unit.
+     */
+    isDateBased() {
+        abstractMethodFail('isDateBased');
+    }
+
+    /**
+     * Checks if this unit is time-based.
+     *
+     * @return {boolean} `true` if time unit, `false` if a date unit.
+     */
+    isTimeBased() {
+        abstractMethodFail('isTimeBased');
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Checks if this unit is supported by the specified temporal object.
+     *
+     * This checks that the implementing date-time can add/subtract this unit.
+     * This can be used to avoid throwing an exception.
+     *
+     * @param {!Temporal} temporal the temporal object to check.
+     * @return {boolean} `true` if the unit is supported.
+     */
+    // eslint-disable-next-line no-unused-vars
+    isSupportedBy(temporal) {
+        abstractMethodFail('isSupportedBy');
+    }
+
+    /**
+     * Returns a copy of the specified temporal object with the specified period added.
+     *
+     * The period added is a multiple of this unit. For example, this method
+     * could be used to add "3 days" to a date by calling this method on the
+     * instance representing "days", passing the date and the period "3".
+     * The period to be added may be negative, which is equivalent to subtraction.
+     *
+     * There are two equivalent ways of using this method.
+     * The first is to invoke this method directly.
+     * The second is to use {@link Temporal#plus}:
+     * <pre>
+     *   // these two lines are equivalent, but the second approach is recommended
+     *   temporal = thisUnit.doPlus(temporal);
+     *   temporal = temporal.plus(thisUnit);
+     * </pre>
+     * It is recommended to use the second approach, {@link plus},
+     * as it is a lot clearer to read in code.
+     *
+     * Implementations should perform any queries or calculations using the units
+     * available in {@link ChronoUnit} or the fields available in {@link ChronoField}.
+     * If the field is not supported a {@link DateTimeException} must be thrown.
+     *
+     * Implementations must not alter the specified temporal object.
+     * Instead, an adjusted copy of the original must be returned.
+     * This provides equivalent, safe behavior for immutable and mutable implementations.
+     *
+     * @param {!Temporal} dateTime the temporal object to adjust.
+     * @param {number} periodToAdd the period of this unit to add, positive or negative.
+     * @return {Temporal} the adjusted temporal object.
+     * @throws DateTimeException if the period cannot be added.
+     */
+    // eslint-disable-next-line no-unused-vars
+    addTo(dateTime, periodToAdd) {
+        abstractMethodFail('addTo');
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Calculates the period in terms of this unit between two temporal objects of the same type.
+     *
+     * This calculates the period between two temporals in terms of this unit.
+     * The start and end points are supplied as temporal objects and must be of the same type.
+     * The result will be negative if the end is before the start.
+     * For example, the period in hours between two temporal objects can be calculated
+     * using {@link HOURS.between}.
+     *
+     * The calculation returns a whole number, representing the number of complete units between the two temporals.
+     * For example, the period in hours between the times 11:30 and 13:29 will only be
+     * one hour as it is one minute short of two hours.
+     *
+     * There are two equivalent ways of using this method.
+     * The first is to invoke this method directly.
+     * The second is to use {@link Temporal#until}:
+     * <pre>
+     *   // these two lines are equivalent
+     *   between = thisUnit.between(start, end);
+     *   between = start.until(end, thisUnit);
+     * </pre>
+     * The choice should be made based on which makes the code more readable.
+     *
+     * For example, this method allows the number of days between two dates to be calculated:
+     * <pre>
+     *   long daysBetween = DAYS.between(start, end);
+     *   // or alternatively
+     *   long daysBetween = start.until(end, DAYS);
+     * </pre>
+     * Implementations should perform any queries or calculations using the units available in
+     * {@link ChronoUnit} or the fields available in {@link ChronoField}.
+     * If the unit is not supported a {@link DateTimeException} must be thrown.
+     * Implementations must not alter the specified temporal objects.
+     *
+     * @param {!Temporal} temporal1 the base temporal object.
+     * @param {!Temporal} temporal2 the other temporal object.
+     * @return {number} the period between temporal1 and temporal2 in terms of this unit;
+     *  positive if temporal2 is later than temporal1, negative if earlier.
+     * @throws DateTimeException if the period cannot be calculated.
+     * @throws ArithmeticException if numeric overflow occurs.
+     */
+    // eslint-disable-next-line no-unused-vars
+    between(temporal1, temporal2) {
+        abstractMethodFail('between');
+    }
+}

package/node_modules/@js-joda/core/src/temporal/ValueRange.js

@@ -0,0 +1,257 @@
+/**
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {assert} from '../assert';
+import {DateTimeException, IllegalArgumentException} from '../errors';
+import {MathUtil} from '../MathUtil';
+
+/**
+ * The range of valid values for a date-time field.
+ *
+ * All TemporalField instances have a valid range of values.
+ * For example, the ISO day-of-month runs from 1 to somewhere between 28 and 31.
+ * This class captures that valid range.
+ *
+ * It is important to be aware of the limitations of this class.
+ * Only the minimum and maximum values are provided.
+ * It is possible for there to be invalid values within the outer range.
+ * For example, a weird field may have valid values of 1, 2, 4, 6, 7, thus
+ * have a range of '1 - 7', despite that fact that values 3 and 5 are invalid.
+ *
+ * Instances of this class are not tied to a specific field.
+ */
+export class ValueRange {
+
+    /**
+     *
+     * @param {!number} minSmallest
+     * @param {!number} minLargest
+     * @param {!number} maxSmallest
+     * @param {!number} maxLargest
+     * @private
+     */
+    constructor(minSmallest, minLargest, maxSmallest, maxLargest) {
+        assert(!(minSmallest > minLargest), 'Smallest minimum value \'' + minSmallest +
+            '\' must be less than largest minimum value \'' + minLargest + '\'', IllegalArgumentException);
+        assert(!(maxSmallest > maxLargest), 'Smallest maximum value \'' + maxSmallest +
+            '\' must be less than largest maximum value \'' + maxLargest + '\'', IllegalArgumentException);
+        assert(!(minLargest > maxLargest), 'Minimum value \'' + minLargest +
+            '\' must be less than maximum value \'' + maxLargest + '\'', IllegalArgumentException);
+
+        this._minSmallest = minSmallest;
+        this._minLargest = minLargest;
+        this._maxLargest = maxLargest;
+        this._maxSmallest = maxSmallest;
+    }
+
+    /**
+     * Is the value range fixed and fully known.
+     *
+     * For example, the ISO day-of-month runs from 1 to between 28 and 31.
+     * Since there is uncertainty about the maximum value, the range is not fixed.
+     * However, for the month of January, the range is always 1 to 31, thus it is fixed.
+     *
+     * @return {boolean} true if the set of values is fixed
+     */
+    isFixed() {
+        return this._minSmallest === this._minLargest && this._maxSmallest === this._maxLargest;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    minimum(){
+        return this._minSmallest;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    largestMinimum(){
+        return this._minLargest;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    maximum(){
+        return this._maxLargest;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    smallestMaximum(){
+        return this._maxSmallest;
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    isValidValue(value) {
+        return (this.minimum() <= value && value <= this.maximum());
+    }
+
+    /**
+     *
+     * @param {number} value
+     * @param {TemporalField} field
+     */
+    checkValidValue(value, field) {
+        let msg;
+        if (!this.isValidValue(value)) {
+            if (field != null) {
+                msg = ('Invalid value for ' + field + ' (valid values ' + (this.toString()) + '): ') + value;
+            } else {
+                msg = ('Invalid value (valid values ' + (this.toString()) + '): ') + value;
+            }
+            return assert(false, msg, DateTimeException);
+        }
+        return value;
+    }
+
+    /**
+     * Checks that the specified value is valid and fits in an `int`.
+     *
+     * This validates that the value is within the valid range of values and that
+     * all valid values are within the bounds of an `int`.
+     * The field is only used to improve the error message.
+     *
+     * @param {number} value - the value to check
+     * @param {TemporalField} field - the field being checked, may be null
+     * @return {number} the value that was passed in
+     * @see #isValidIntValue(long)
+     */
+    checkValidIntValue(value, field) {
+        if (this.isValidIntValue(value) === false) {
+            throw new DateTimeException('Invalid int value for ' + field + ': ' + value);
+        }
+        return value;
+    }
+
+    /**
+     * Checks if the value is within the valid range and that all values
+     * in the range fit in an `int`.
+     *
+     * This method combines {@link isIntValue} and {@link isValidValue}.
+     *
+     * @param {number} value - the value to check
+     * @return true if the value is valid and fits in an `int`
+     */
+    isValidIntValue(value) {
+        return this.isIntValue() && this.isValidValue(value);
+    }
+
+    /**
+     * Checks if all values in the range fit in an `int`.
+     *
+     * This checks that all valid values are within the bounds of an `int`.
+     *
+     * For example, the ISO month-of-year has values from 1 to 12, which fits in an `int`.
+     * By comparison, ISO nano-of-day runs from 1 to 86,400,000,000,000 which does not fit in an `int`.
+     *
+     * This implementation uses {@link getMinimum} and {@link getMaximum}.
+     *
+     * @return boolean if a valid value always fits in an `int`
+     */
+    isIntValue() { // should be isSafeIntegerValue
+        return this.minimum() >= MathUtil.MIN_SAFE_INTEGER && this.maximum() <= MathUtil.MAX_SAFE_INTEGER;
+    }
+
+    /**
+     * Checks if this range is equal to another range.
+     *
+     * The comparison is based on the four values, minimum, largest minimum,
+     * smallest maximum and maximum.
+     * Only objects of type {@link ValueRange} are compared, other types return false.
+     *
+     * @param {*} other - the object to check, null returns false
+     * @return {boolean} true if this is equal to the other range
+     */
+    equals(other) {
+        if (other === this) {
+            return true;
+        }
+        if (other instanceof ValueRange) {
+            return this._minSmallest === other._minSmallest && this._minLargest === other._minLargest &&
+                this._maxSmallest === other._maxSmallest && this._maxLargest === other._maxLargest;
+        }
+        return false;
+    }
+
+    /**
+     * A hash code for this range.
+     *
+     * @return {number} a suitable hash code
+     */
+    hashCode() {
+        return MathUtil.hashCode(this._minSmallest, this._minLargest, this._maxSmallest, this._maxLargest);
+    }
+
+    /*
+     * Outputs this range as a String.
+     *
+     * The format will be '{min}/{largestMin} - {smallestMax}/{max}',
+     * where the largestMin or smallestMax sections may be omitted, together
+     * with associated slash, if they are the same as the min or max.
+     *
+     * @return {string} a string representation of this range, not null
+     */
+    toString() {
+        let str = this.minimum() + (this.minimum() !== this.largestMinimum() ? '/' + (this.largestMinimum()) : '');
+        str += ' - ';
+        str += this.smallestMaximum() + (this.smallestMaximum() !== this.maximum() ? '/' + (this.maximum()) : '');
+        return str;
+    }
+
+    /*
+     * called with 2 params: Obtains a fixed value range.
+     *
+     * This factory obtains a range where the minimum and maximum values are fixed.
+     * For example, the ISO month-of-year always runs from 1 to 12.
+     *
+     * @param min  the minimum value
+     * @param max  the maximum value
+     * @return the ValueRange for min, max, not null
+
+     * called with 3 params: Obtains a variable value range.
+     *
+     * This factory obtains a range where the minimum value is fixed and the maximum value may vary.
+     * For example, the ISO day-of-month always starts at 1, but ends between 28 and 31.
+     *
+     * @param min  the minimum value
+     * @param maxSmallest  the smallest maximum value
+     * @param maxLargest  the largest maximum value
+     * @return the ValueRange for min, smallest max, largest max, not null
+
+     * called with 4 params: Obtains a fully variable value range.
+     *
+     * This factory obtains a range where both the minimum and maximum value may vary.
+     *
+     * @param minSmallest  the smallest minimum value
+     * @param minLargest  the largest minimum value
+     * @param maxSmallest  the smallest maximum value
+     * @param maxLargest  the largest maximum value
+     *
+     * @return {ValueRange} the ValueRange for smallest min, largest min, smallest max, largest max, not null
+     */
+    static of() {
+        if (arguments.length === 2) {
+            return new ValueRange(arguments[0], arguments[0], arguments[1], arguments[1]);
+        } else if (arguments.length === 3) {
+            return new ValueRange(arguments[0], arguments[0], arguments[1], arguments[2]);
+        } else if (arguments.length === 4) {
+            return new ValueRange(arguments[0], arguments[1], arguments[2], arguments[3]);
+        } else {
+            return assert(false, 'Invalid number of arguments ' + arguments.length, IllegalArgumentException);
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+
+export function bindUse(jsJoda) {
+    const used = [];
+
+    /**
+     * use
+     *
+     * Provides a way to extend the internals of js-joda
+     *
+     * @param {function} fn - function to extend js-joda public api
+     * @returns {this} for chaining
+     */
+    return function use(fn) {
+        if (!~used.indexOf(fn)) {
+            fn(jsJoda);
+            used.push(fn);
+        }
+        return jsJoda;
+    };
+}

package/node_modules/@js-joda/core/src/zone/SystemDefaultZoneId.js

@@ -0,0 +1,31 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {SystemDefaultZoneRules} from './SystemDefaultZoneRules';
+import {ZoneId} from '../ZoneId';
+
+export class SystemDefaultZoneId extends ZoneId {
+
+    constructor(){
+        super();
+        this._rules = new SystemDefaultZoneRules();
+    }
+
+    rules(){
+        return this._rules;
+    }
+
+    equals(other){
+        if(this === other){
+            return true;
+        }
+        return false;
+    }
+
+    id(){
+        return 'SYSTEM';
+    }
+
+}

package/node_modules/@js-joda/core/src/zone/SystemDefaultZoneRules.js

@@ -0,0 +1,162 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {ZoneRules} from './ZoneRules';
+import {ZoneOffset} from '../ZoneOffset';
+import {DateTimeException} from '../errors';
+
+export class SystemDefaultZoneRules extends ZoneRules {
+
+    isFixedOffset(){
+        return false;
+    }
+
+    /**
+     *
+     * @param {Instant} instant
+     * @returns {ZoneOffset}
+     */
+    offsetOfInstant(instant){
+        const offsetInMinutes = new Date(instant.toEpochMilli()).getTimezoneOffset();
+        return ZoneOffset.ofTotalMinutes(offsetInMinutes * -1);
+    }
+
+    /**
+     *
+     * @param {number} epochMilli
+     * @returns {ZoneOffset}
+     */
+    offsetOfEpochMilli(epochMilli){
+        const offsetInMinutes = new Date(epochMilli).getTimezoneOffset();
+        return ZoneOffset.ofTotalMinutes(offsetInMinutes * -1);
+    }
+
+    /**
+     * This implementation is NOT returning the best value in a gap or overlap situation
+     * as specified at {@link ZoneRules.offsetOfLocalDateTime}.
+     *
+     * The calculated offset depends Date.prototype.getTimezoneOffset and its not specified
+     * at the ECMA-262 specification how to handle daylight savings gaps/ overlaps.
+     *
+     * The Chrome Browser version 49 is returning the next transition offset in a gap/overlap situation,
+     * other browsers/ engines might do it in the same way.
+     *
+     * @param {LocalDateTime} localDateTime
+     * @returns {ZoneOffset}
+     */
+    offsetOfLocalDateTime(localDateTime){
+        const epochMilli = localDateTime.toEpochSecond(ZoneOffset.UTC) * 1000;
+        const offsetInMinutesBeforePossibleTransition = new Date(epochMilli).getTimezoneOffset();
+        const epochMilliSystemZone = epochMilli + offsetInMinutesBeforePossibleTransition * 60000;
+        const offsetInMinutesAfterPossibleTransition = new Date(epochMilliSystemZone).getTimezoneOffset();
+        return ZoneOffset.ofTotalMinutes(offsetInMinutesAfterPossibleTransition * -1);
+    }
+
+    /**
+     *
+     * @param localDateTime
+     * @return {ZoneOffset[]}
+     */
+    validOffsets(localDateTime){
+        return [this.offsetOfLocalDateTime(localDateTime)];
+    }
+
+    /**
+     * @return null, not supported
+     */
+    transition(){
+        return null;
+    }
+
+    /**
+     *
+     * @param instant
+     * @return {ZoneOffset}
+     */
+    standardOffset(instant){
+        return this.offsetOfInstant(instant);
+    }
+
+    /**
+     * @throws DateTimeException not supported
+     */
+    daylightSavings(){
+        this._throwNotSupported();
+    }
+
+    /**
+     * @throws DateTimeException not supported
+     */
+    isDaylightSavings(){
+        this._throwNotSupported();
+    }
+
+    /**
+     *
+     * @param {LocalDateTime} dateTime
+     * @param {ZoneOffset} offset
+     * @return {boolean}
+     */
+    isValidOffset(dateTime, offset) {
+        return this.offsetOfLocalDateTime(dateTime).equals(offset);
+    }
+
+    /**
+     * @throws DateTimeException not supported
+     */
+    nextTransition(){
+        this._throwNotSupported();
+    }
+
+    /**
+     * @throws DateTimeException not supported
+     */
+    previousTransition(){
+        this._throwNotSupported();
+    }
+
+    /**
+     * @throws DateTimeException not supported
+     */
+    transitions(){
+        this._throwNotSupported();
+    }
+
+    /**
+     * @throws DateTimeException not supported
+     */
+    transitionRules(){
+        this._throwNotSupported();
+    }
+
+    /**
+     * @throws DateTimeException not supported
+     */
+    _throwNotSupported(){
+        throw new DateTimeException('not supported operation');
+    }
+    //-----------------------------------------------------------------------
+    /**
+     *
+     * @param {*} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other || other instanceof SystemDefaultZoneRules) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    toString() {
+        return 'SYSTEM';
+    }
+
+}