@attocash/cli 0.1.0

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

@@ -0,0 +1,486 @@
+/**
+ * @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 {requireNonNull} from './assert';
+import {DateTimeException} from './errors';
+import {MathUtil} from './MathUtil';
+
+import {LocalTime} from './LocalTime';
+import {ZoneId} from './ZoneId';
+
+import {ChronoField} from './temporal/ChronoField';
+import {TemporalQueries} from './temporal/TemporalQueries';
+
+import {ZoneRules} from './zone/ZoneRules';
+
+const SECONDS_CACHE = {};
+const ID_CACHE = {};
+
+/**
+ *
+ * ### Static properties of Class {@link LocalDate}
+ *
+ * ZoneOffset.MAX_SECONDS = 18 * LocalTime.SECONDS_PER_HOUR;
+ *
+ * ZoneOffset.UTC = ZoneOffset.ofTotalSeconds(0);
+ *
+ * ZoneOffset.MIN = ZoneOffset.ofTotalSeconds(-ZoneOffset.MAX_SECONDS);
+ *
+ * ZoneOffset.MAX = ZoneOffset.ofTotalSeconds(ZoneOffset.MAX_SECONDS);
+ *
+ */
+export class ZoneOffset extends ZoneId {
+    /**
+     *
+     * @param {number} totalSeconds
+     * @private
+     */
+    constructor(totalSeconds){
+        super();
+        ZoneOffset._validateTotalSeconds(totalSeconds);
+        this._totalSeconds = MathUtil.safeToInt(totalSeconds);
+        this._rules = ZoneRules.of(this);
+        this._id = ZoneOffset._buildId(totalSeconds);
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    totalSeconds() {
+        return this._totalSeconds;
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    id() {
+        return this._id;
+    }
+
+    /**
+     *
+     * @param {number} totalSeconds
+     * @returns {string}
+     */
+    static _buildId(totalSeconds) {
+        if (totalSeconds === 0) {
+            return 'Z';
+        } else {
+            const absTotalSeconds = Math.abs(totalSeconds);
+            const absHours = MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_HOUR);
+            const absMinutes = MathUtil.intMod(MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE), LocalTime.MINUTES_PER_HOUR);
+            let buf = '' + (totalSeconds < 0 ? '-' : '+')
+                + (absHours < 10 ? '0' : '') + (absHours)
+                + (absMinutes < 10 ? ':0' : ':') + (absMinutes);
+            const absSeconds = MathUtil.intMod(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE);
+            if (absSeconds !== 0) {
+                buf += (absSeconds < 10 ? ':0' : ':') + (absSeconds);
+            }
+            return buf;
+        }
+    }
+
+
+    /**
+     *
+     * @param {number} totalSeconds
+     * @private
+     */
+    static _validateTotalSeconds(totalSeconds){
+        if (Math.abs(totalSeconds) > ZoneOffset.MAX_SECONDS) {
+            throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');
+        }
+    }
+
+    /**
+     *
+     * @param {number} hours
+     * @param {number} minutes
+     * @param {number} seconds
+     * @private
+     */
+    static _validate(hours, minutes, seconds) {
+        if (hours < -18 || hours > 18) {
+            throw new DateTimeException('Zone offset hours not in valid range: value ' + hours +
+                    ' is not in the range -18 to 18');
+        }
+        if (hours > 0) {
+            if (minutes < 0 || seconds < 0) {
+                throw new DateTimeException('Zone offset minutes and seconds must be positive because hours is positive');
+            }
+        } else if (hours < 0) {
+            if (minutes > 0 || seconds > 0) {
+                throw new DateTimeException('Zone offset minutes and seconds must be negative because hours is negative');
+            }
+        } else if ((minutes > 0 && seconds < 0) || (minutes < 0 && seconds > 0)) {
+            throw new DateTimeException('Zone offset minutes and seconds must have the same sign');
+        }
+        if (Math.abs(minutes) > 59) {
+            throw new DateTimeException('Zone offset minutes not in valid range: abs(value) ' +
+                    Math.abs(minutes) + ' is not in the range 0 to 59');
+        }
+        if (Math.abs(seconds) > 59) {
+            throw new DateTimeException('Zone offset seconds not in valid range: abs(value) ' +
+                    Math.abs(seconds) + ' is not in the range 0 to 59');
+        }
+        if (Math.abs(hours) === 18 && (Math.abs(minutes) > 0 || Math.abs(seconds) > 0)) {
+            throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');
+        }
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Obtains an instance of {@link ZoneOffset} using the ID.
+     *
+     * This method parses the string ID of a {@link ZoneOffset} to
+     * return an instance. The parsing accepts all the formats generated by
+     * {@link getId}, plus some additional formats:
+     *
+     * * {@link Z} - for UTC
+     * * `+h`
+     * * `+hh`
+     * * `+hh:mm`
+     * * `-hh:mm`
+     * * `+hhmm`
+     * * `-hhmm`
+     * * `+hh:mm:ss`
+     * * `-hh:mm:ss`
+     * * `+hhmmss`
+     * * `-hhmmss`
+     *
+     * Note that &plusmn; means either the plus or minus symbol.
+     *
+     * The ID of the returned offset will be normalized to one of the formats
+     * described by {@link getId}.
+     *
+     * The maximum supported range is from +18:00 to -18:00 inclusive.
+     *
+     * @param {string} offsetId  the offset ID, not null
+     * @return {ZoneOffset} the zone-offset, not null
+     * @throws DateTimeException if the offset ID is invalid
+     */
+    static of(offsetId) {
+        requireNonNull(offsetId, 'offsetId');
+        // "Z" is always in the cache
+        const offset = ID_CACHE[offsetId];
+        if (offset != null) {
+            return offset;
+        }
+
+        // parse - +h, +hh, +hhmm, +hh:mm, +hhmmss, +hh:mm:ss
+        let hours, minutes, seconds;
+        switch (offsetId.length) {
+            case 2:
+                offsetId = offsetId[0] + '0' + offsetId[1];  // fallthru
+            // eslint-disable-next-line no-fallthrough
+            case 3:
+                hours = ZoneOffset._parseNumber(offsetId, 1, false);
+                minutes = 0;
+                seconds = 0;
+                break;
+            case 5:
+                hours = ZoneOffset._parseNumber(offsetId, 1, false);
+                minutes = ZoneOffset._parseNumber(offsetId, 3, false);
+                seconds = 0;
+                break;
+            case 6:
+                hours = ZoneOffset._parseNumber(offsetId, 1, false);
+                minutes = ZoneOffset._parseNumber(offsetId, 4, true);
+                seconds = 0;
+                break;
+            case 7:
+                hours = ZoneOffset._parseNumber(offsetId, 1, false);
+                minutes = ZoneOffset._parseNumber(offsetId, 3, false);
+                seconds = ZoneOffset._parseNumber(offsetId, 5, false);
+                break;
+            case 9:
+                hours = ZoneOffset._parseNumber(offsetId, 1, false);
+                minutes = ZoneOffset._parseNumber(offsetId, 4, true);
+                seconds = ZoneOffset._parseNumber(offsetId, 7, true);
+                break;
+            default:
+                throw new DateTimeException('Invalid ID for ZoneOffset, invalid format: ' + offsetId);
+        }
+        const first = offsetId[0];
+        if (first !== '+' && first !== '-') {
+            throw new DateTimeException('Invalid ID for ZoneOffset, plus/minus not found when expected: ' + offsetId);
+        }
+        if (first === '-') {
+            return ZoneOffset.ofHoursMinutesSeconds(-hours, -minutes, -seconds);
+        } else {
+            return ZoneOffset.ofHoursMinutesSeconds(hours, minutes, seconds);
+        }
+    }
+
+    /**
+     * Parse a two digit zero-prefixed number.
+     *
+     * @param {string} offsetId - the offset ID, not null
+     * @param {number} pos - the position to parse, valid
+     * @param {boolean} precededByColon - should this number be prefixed by a precededByColon
+     * @return {number} the parsed number, from 0 to 99
+     */
+    static _parseNumber(offsetId, pos, precededByColon) {
+        if (precededByColon && offsetId[pos - 1] !== ':') {
+            throw new DateTimeException('Invalid ID for ZoneOffset, colon not found when expected: ' + offsetId);
+        }
+        const ch1 = offsetId[pos];
+        const ch2 = offsetId[pos + 1];
+        if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
+            throw new DateTimeException('Invalid ID for ZoneOffset, non numeric characters found: ' + offsetId);
+        }
+        return (ch1.charCodeAt(0) - 48) * 10 + (ch2.charCodeAt(0) - 48);
+    }
+
+    /**
+     *
+     * @param {number} hours
+     * @returns {ZoneOffset}
+     */
+    static ofHours(hours) {
+        return ZoneOffset.ofHoursMinutesSeconds(hours, 0, 0);
+    }
+
+    /**
+     *
+     * @param {number} hours
+     * @param {number} minutes
+     * @returns {ZoneOffset}
+     */
+    static ofHoursMinutes(hours, minutes) {
+        return ZoneOffset.ofHoursMinutesSeconds(hours, minutes, 0);
+    }
+
+    /**
+     *
+     * @param {number} hours
+     * @param {number} minutes
+     * @param {number} seconds
+     * @returns {ZoneOffset}
+     */
+    static ofHoursMinutesSeconds(hours, minutes, seconds) {
+        ZoneOffset._validate(hours, minutes, seconds);
+        const totalSeconds = hours * LocalTime.SECONDS_PER_HOUR + minutes * LocalTime.SECONDS_PER_MINUTE + seconds;
+        return ZoneOffset.ofTotalSeconds(totalSeconds);
+    }
+
+    /**
+     *
+     * @param {number} totalMinutes
+     * @returns {ZoneOffset}
+     */
+    static ofTotalMinutes(totalMinutes) {
+        const totalSeconds = totalMinutes * LocalTime.SECONDS_PER_MINUTE;
+        return ZoneOffset.ofTotalSeconds(totalSeconds);
+    }
+
+    /**
+     *
+     * @param {number} totalSeconds
+     * @returns {ZoneOffset}
+     */
+    static ofTotalSeconds(totalSeconds) {
+        if (totalSeconds % (15 * LocalTime.SECONDS_PER_MINUTE) === 0) {
+            const totalSecs = totalSeconds;
+            let result = SECONDS_CACHE[totalSecs];
+            if (result == null) {
+                result = new ZoneOffset(totalSeconds);
+                SECONDS_CACHE[totalSecs] = result;
+                ID_CACHE[result.id()] = result;
+            }
+            return result;
+        } else {
+            return new ZoneOffset(totalSeconds);
+        }
+    }
+
+    /**
+     * Gets the associated time-zone rules.
+     *
+     * The rules will always return this offset when queried.
+     * The implementation class is immutable, thread-safe and serializable.
+     *
+     * @return {ZoneRules} the rules, not null
+     */
+    rules() {
+        return this._rules;
+    }
+
+    /**
+      * Gets the value of the specified field from this offset as an `int`.
+      *
+      * This queries this offset for the value for the specified field.
+      * The returned value will always be within the valid range of values for the field.
+      * If it is not possible to return the value, because the field is not supported
+      * or for some other reason, an exception is thrown.
+      *
+      * If the field is a {@link ChronoField} then the query is implemented here.
+      * The {@link OFFSET_SECONDS} field returns the value of the offset.
+      * All other {@link ChronoField} instances will throw a {@link DateTimeException}.
+      *
+      * If the field is not a {@link ChronoField}, then the result of this method
+      * is obtained by invoking {@link TemporalField.getFrom}
+      * passing `this` as the argument. Whether the value can be obtained,
+      * and what the value represents, is determined by the field.
+      *
+      * @param {TemporalField} field - the field to get, not null
+      * @return {number} the value for the field
+      * @throws DateTimeException if a value for the field cannot be obtained
+      * @throws ArithmeticException if numeric overflow occurs
+      */
+    get(field) {
+        return this.getLong(field);
+    }
+
+    /**
+      * Gets the value of the specified field from this offset as a `long`.
+      *
+      * This queries this offset for the value for the specified field.
+      * If it is not possible to return the value, because the field is not supported
+      * or for some other reason, an exception is thrown.
+      *
+      * If the field is a {@link ChronoField} then the query is implemented here.
+      * The {@link OFFSET_SECONDS} field returns the value of the offset.
+      * All other {@link ChronoField} instances will throw a {@link DateTimeException}.
+      *
+      * If the field is not a {@link ChronoField}, then the result of this method
+      * is obtained by invoking {@link TemporalField.getFrom}
+      * passing `this` as the argument. Whether the value can be obtained,
+      * and what the value represents, is determined by the field.
+      *
+      * @param {TemporalField} field - the field to get, not null
+      * @return {number} the value for the field
+      * @throws DateTimeException if a value for the field cannot be obtained
+      * @throws ArithmeticException if numeric overflow occurs
+      */
+    getLong(field) {
+        if (field === ChronoField.OFFSET_SECONDS) {
+            return this._totalSeconds;
+        } else if (field instanceof ChronoField) {
+            throw new DateTimeException('Unsupported field: ' + field);
+        }
+        return field.getFrom(this);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+      * Queries this offset using the specified query.
+      *
+      * This queries this offset using the specified query strategy object.
+      * The {@link TemporalQuery} object defines the logic to be used to
+      * obtain the result. Read the documentation of the query to understand
+      * what the result of this method will be.
+      *
+      * The result of this method is obtained by invoking the
+      * {@link TemporalQuery#queryFrom} method on the
+      * specified query passing `this` as the argument.
+      *
+      * @param {TemporalQuery} query - the query to invoke, not null
+      * @return {*} the query result, null may be returned (defined by the query)
+      * @throws DateTimeException if unable to query (defined by the query)
+      * @throws ArithmeticException if numeric overflow occurs (defined by the query)
+      */
+    query(query) {
+        requireNonNull(query, 'query');
+        if (query === TemporalQueries.offset() || query === TemporalQueries.zone()) {
+            return this;
+        } else if (query === TemporalQueries.localDate() || query === TemporalQueries.localTime() ||
+                 query === TemporalQueries.precision() || query === TemporalQueries.chronology() || query === TemporalQueries.zoneId()) {
+            return null;
+        }
+        return query.queryFrom(this);
+    }
+
+    /**
+      * Adjusts the specified temporal object to have the same offset as this object.
+      *
+      * This returns a temporal object of the same observable type as the input
+      * with the offset changed to be the same as this.
+      *
+      * The adjustment is equivalent to using {@link Temporal#with}
+      * passing {@link ChronoField#OFFSET_SECONDS} as the field.
+      *
+      * In most cases, it is clearer to reverse the calling pattern by using
+      * {@link Temporal#with}:
+      * <pre>
+      *   // these two lines are equivalent, but the second approach is recommended
+      *   temporal = thisOffset.adjustInto(temporal);
+      *   temporal = temporal.with(thisOffset);
+      * </pre>
+      *
+      * This instance is immutable and unaffected by this method call.
+      *
+      * @param {Temporal} temporal - the target object to be adjusted, not null
+      * @return {Temporal} the adjusted object, not null
+      * @throws DateTimeException if unable to make the adjustment
+      * @throws ArithmeticException if numeric overflow occurs
+      */
+    adjustInto(temporal) {
+        return temporal.with(ChronoField.OFFSET_SECONDS, this._totalSeconds);
+    }
+
+    /**
+     * Compares this offset to another offset in descending order.
+     *
+     * The offsets are compared in the order that they occur for the same time
+     * of day around the world. Thus, an offset of `+10:00` comes before an
+     * offset of `+09:00` and so on down to `-18:00`.
+     *
+     * The comparison is "consistent with equals", as defined by {@link Comparable}.
+     *
+     * @param {!ZoneOffset} other - the other date to compare to, not null
+     * @return {number} the comparator value, negative if less, positive if greater
+     * @throws NullPointerException if {@link other} is null
+     */
+    compareTo(other) {
+        requireNonNull(other, 'other');
+        return other._totalSeconds - this._totalSeconds;
+    }
+
+
+    /**
+     * Checks if this offset is equal to another offset.
+     *
+     * The comparison is based on the amount of the offset in seconds.
+     * This is equivalent to a comparison by ID.
+     *
+     * @param {*} obj - the object to check, null returns false
+     * @return {boolean} true if this is equal to the other offset
+     */
+    equals(obj) {
+        if (this === obj) {
+            return true;
+        }
+        if (obj instanceof ZoneOffset) {
+            return this._totalSeconds === obj._totalSeconds;
+        }
+        return false;
+    }
+
+    /**
+     * @return {number}
+     */
+    hashCode(){
+        return this._totalSeconds;
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    toString(){
+        return this._id;
+    }
+}
+
+export function _init() {
+    ZoneOffset.MAX_SECONDS = 18 * LocalTime.SECONDS_PER_HOUR;
+    ZoneOffset.UTC = ZoneOffset.ofTotalSeconds(0);
+    ZoneOffset.MIN = ZoneOffset.ofTotalSeconds(-ZoneOffset.MAX_SECONDS);
+    ZoneOffset.MAX = ZoneOffset.ofTotalSeconds(ZoneOffset.MAX_SECONDS);
+}

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

@@ -0,0 +1,72 @@
+/*
+ * @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 {ZoneId} from './ZoneId';
+import {ZoneRulesProvider} from './zone/ZoneRulesProvider';
+
+/**
+ * A geographical region where the same time-zone rules apply.
+ *
+ * Time-zone information is categorized as a set of rules defining when and
+ * how the offset from UTC/Greenwich changes. These rules are accessed using
+ * identifiers based on geographical regions, such as countries or states.
+ * The most common region classification is the Time Zone Database (TZDB),
+ * which defines regions such as 'Europe/Paris' and 'Asia/Tokyo'.
+ *
+ * The region identifier, modeled by this class, is distinct from the
+ * underlying rules, modeled by {@link ZoneRules}.
+ * The rules are defined by governments and change frequently.
+ * By contrast, the region identifier is well-defined and long-lived.
+ * This separation also allows rules to be shared between regions if appropriate.
+ *
+ * ### Specification for implementors
+ *
+ * This class is immutable and thread-safe.
+ */
+export class ZoneRegion extends ZoneId {
+    /**
+     * not yet implemented
+     * @param {string} zoneId
+     * @return {ZoneId}
+     */
+    static ofId(zoneId){
+        const rules = ZoneRulesProvider.getRules(zoneId);
+        return new ZoneRegion(zoneId, rules);
+    }
+
+    //-------------------------------------------------------------------------
+    /**
+     * Constructor.
+     *
+     * @param {string} id  the time-zone ID, not null
+     * @param {ZoneRules} rules  the rules, null for lazy lookup
+     * @private
+     */
+    constructor(id, rules) {
+        super();
+        this._id = id;
+        this._rules = rules;
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     *
+     * @returns {string}
+     */
+    id() {
+        return this._id;
+    }
+
+    /**
+     *
+     * @returns {ZoneRules}
+     */
+    rules() {
+        return this._rules;
+    }
+
+}