@attocash/cli 0.1.0

package/node_modules/@js-joda/core/src/format/parser/NumberPrinterParser.js

@@ -0,0 +1,367 @@
+/**
+ * @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 {ArithmeticException, DateTimeException, IllegalArgumentException} from '../../errors';
+import {MathUtil} from '../../MathUtil';
+
+import {IsoChronology} from '../../chrono/IsoChronology';
+
+import {SignStyle} from '../SignStyle';
+
+
+const MAX_WIDTH = 15; // can't parse all numbers with more then 15 digits in javascript
+
+const EXCEED_POINTS = [
+    0,
+    10,
+    100,
+    1000,
+    10000,
+    100000,
+    1000000,
+    10000000,
+    100000000,
+    1000000000
+];
+
+/**
+ * @private
+ */
+export class NumberPrinterParser {
+
+    /**
+     * Constructor.
+     *
+     * @param field  the field to print, not null
+     * @param minWidth  the minimum field width, from 1 to 19
+     * @param maxWidth  the maximum field width, from minWidth to 19
+     * @param signStyle  the positive/negative sign style, not null
+     * @param subsequentWidth  the width of subsequent non-negative numbers, 0 or greater,
+     *  -1 if fixed width due to active adjacent parsing
+     */
+    constructor(field, minWidth, maxWidth, signStyle, subsequentWidth=0){
+        this._field = field;
+        this._minWidth = minWidth;
+        this._maxWidth = maxWidth;
+        this._signStyle = signStyle;
+        this._subsequentWidth = subsequentWidth;
+    }
+
+    field(){ return this._field;}
+    minWidth(){ return this._minWidth;}
+    maxWidth(){ return this._maxWidth;}
+    signStyle(){ return this._signStyle;}
+
+    withFixedWidth() {
+        if (this._subsequentWidth === -1) {
+            return this;
+        }
+        return new NumberPrinterParser(this._field, this._minWidth, this._maxWidth, this._signStyle, -1);
+    }
+
+    withSubsequentWidth(subsequentWidth) {
+        return new NumberPrinterParser(this._field, this._minWidth, this._maxWidth, this._signStyle, this._subsequentWidth + subsequentWidth);
+    }
+
+    _isFixedWidth() {
+        return this._subsequentWidth === -1 ||
+            (this._subsequentWidth > 0 && this._minWidth === this._maxWidth && this._signStyle === SignStyle.NOT_NEGATIVE);
+    }
+
+    print(context, buf) {
+        const contextValue = context.getValue(this._field);
+        if (contextValue == null) {
+            return false;
+        }
+        const value = this._getValue(context, contextValue);
+        const symbols = context.symbols();
+        let str = '' + Math.abs(value);
+        if (str.length > this._maxWidth) {
+            throw new DateTimeException('Field ' + this._field +
+                ' cannot be printed as the value ' + value +
+                ' exceeds the maximum print width of ' + this._maxWidth);
+        }
+        str = symbols.convertNumberToI18N(str);
+
+        if (value >= 0) {
+            switch (this._signStyle) {
+                case SignStyle.EXCEEDS_PAD:
+                    if (this._minWidth < MAX_WIDTH && value >= EXCEED_POINTS[this._minWidth]) {
+                        buf.append(symbols.positiveSign());
+                    }
+                    break;
+                case SignStyle.ALWAYS:
+                    buf.append(symbols.positiveSign());
+                    break;
+            }
+        } else {
+            switch (this._signStyle) {
+                case SignStyle.NORMAL:
+                case SignStyle.EXCEEDS_PAD:
+                case SignStyle.ALWAYS:
+                    buf.append(symbols.negativeSign());
+                    break;
+                case SignStyle.NOT_NEGATIVE:
+                    throw new DateTimeException('Field ' + this._field +
+                        ' cannot be printed as the value ' + value +
+                        ' cannot be negative according to the SignStyle');
+            }
+        }
+        for (let i = 0; i < this._minWidth - str.length; i++) {
+            buf.append(symbols.zeroDigit());
+        }
+        buf.append(str);
+        return true;
+    }
+
+    parse(context, text, position){
+        const length = text.length;
+        if (position === length) {
+            return ~position;
+        }
+        assert(position>=0 && position<length);
+        const sign = text.charAt(position);  // IOOBE if invalid position
+        let negative = false;
+        let positive = false;
+        if (sign === context.symbols().positiveSign()) {
+            if (this._signStyle.parse(true, context.isStrict(), this._minWidth === this._maxWidth) === false) {
+                return ~position;
+            }
+            positive = true;
+            position++;
+        } else if (sign === context.symbols().negativeSign()) {
+            if (this._signStyle.parse(false, context.isStrict(), this._minWidth === this._maxWidth) === false) {
+                return ~position;
+            }
+            negative = true;
+            position++;
+        } else {
+            if (this._signStyle === SignStyle.ALWAYS && context.isStrict()) {
+                return ~position;
+            }
+        }
+        const effMinWidth = (context.isStrict() || this._isFixedWidth() ? this._minWidth : 1);
+        const minEndPos = position + effMinWidth;
+        if (minEndPos > length) {
+            return ~position;
+        }
+        let effMaxWidth = (context.isStrict() || this._isFixedWidth() ? this._maxWidth : 9) + Math.max(this._subsequentWidth, 0);
+        let total = 0;
+        let pos = position;
+        for (let pass = 0; pass < 2; pass++) {
+            const maxEndPos = Math.min(pos + effMaxWidth, length);
+            while (pos < maxEndPos) {
+                const ch = text.charAt(pos++);
+                const digit = context.symbols().convertToDigit(ch);
+                if (digit < 0) {
+                    pos--;
+                    if (pos < minEndPos) {
+                        return ~position;  // need at least min width digits
+                    }
+                    break;
+                }
+                if ((pos - position) > MAX_WIDTH) {
+                    throw new ArithmeticException('number text exceeds length');
+                } else {
+                    total = total * 10 + digit;
+                }
+            }
+            if (this._subsequentWidth > 0 && pass === 0) {
+                // re-parse now we know the correct width
+                const parseLen = pos - position;
+                effMaxWidth = Math.max(effMinWidth, parseLen - this._subsequentWidth);
+                pos = position;
+                total = 0;
+            } else {
+                break;
+            }
+        }
+        if (negative) {
+            if (total === 0 && context.isStrict()) {
+                return ~(position - 1);  // minus zero not allowed
+            }
+            if(total !== 0) {
+                total = -total;
+            }
+        } else if (this._signStyle === SignStyle.EXCEEDS_PAD && context.isStrict()) {
+            const parseLen = pos - position;
+            if (positive) {
+                if (parseLen <= this._minWidth) {
+                    return ~(position - 1);  // '+' only parsed if minWidth exceeded
+                }
+            } else {
+                if (parseLen > this._minWidth) {
+                    return ~position;  // '+' must be parsed if minWidth exceeded
+                }
+            }
+        }
+        return this._setValue(context, total, position, pos);
+    }
+
+    /**
+     * Gets the value to output.
+     * (This is needed to allow e.g. ReducedPrinterParser to override this and change the value!
+     *
+     * @param context  the context
+     * @param value  the value of the field, not null
+     * @return the value
+     * @private
+     */
+    _getValue(context, value) {
+        return value;
+    }
+
+    /**
+     * Stores the value.
+     *
+     * @param context  the context to store into, not null
+     * @param value  the value
+     * @param errorPos  the position of the field being parsed
+     * @param successPos  the position after the field being parsed
+     * @return the new position
+     */
+    _setValue(context, value, errorPos, successPos) {
+        return context.setParsedField(this._field, value, errorPos, successPos);
+    }
+
+    toString() {
+        if (this._minWidth === 1 && this._maxWidth === MAX_WIDTH && this._signStyle === SignStyle.NORMAL) {
+            return 'Value(' + this._field + ')';
+        }
+        if (this._minWidth === this._maxWidth && this._signStyle === SignStyle.NOT_NEGATIVE) {
+            return 'Value(' + this._field + ',' + this._minWidth + ')';
+        }
+        return 'Value(' + this._field + ',' + this._minWidth + ',' + this._maxWidth + ',' + this._signStyle + ')';
+    }
+
+}
+//-----------------------------------------------------------------------
+/**
+ * Prints and parses a reduced numeric date-time field.
+ * @private
+ */
+export class ReducedPrinterParser extends NumberPrinterParser {
+
+    /**
+     * Constructor.
+     *
+     * @param {TemporalField} field  the field to print, validated not null
+     * @param {number} width  the field width, from 1 to 10
+     * @param {number} maxWidth  the field max width, from 1 to 10
+     * @param {number} baseValue  the base value
+     * @param {ChronoLocalDate} baseDate  the base date
+     */
+    constructor(field, width, maxWidth, baseValue, baseDate) {
+        super(field, width, maxWidth, SignStyle.NOT_NEGATIVE);
+        if (width < 1 || width > 10) {
+            throw new IllegalArgumentException('The width must be from 1 to 10 inclusive but was ' + width);
+        }
+        if (maxWidth < 1 || maxWidth > 10) {
+            throw new IllegalArgumentException('The maxWidth must be from 1 to 10 inclusive but was ' + maxWidth);
+        }
+        if (maxWidth < width) {
+            throw new IllegalArgumentException('The maxWidth must be greater than the width');
+        }
+        if (baseDate === null) {
+            if (field.range().isValidValue(baseValue) === false) {
+                throw new IllegalArgumentException('The base value must be within the range of the field');
+            }
+            if ((baseValue + EXCEED_POINTS[width]) > MathUtil.MAX_SAFE_INTEGER) {
+                throw new DateTimeException('Unable to add printer-parser as the range exceeds the capacity of an int');
+            }
+        }
+        this._baseValue = baseValue;
+        this._baseDate = baseDate;
+    }
+
+    /**
+     *
+     * @param {DateTimePrintContext} context
+     * @param {number} value
+     */
+    _getValue(context, value) {
+        const absValue = Math.abs(value);
+        let baseValue = this._baseValue;
+        if (this._baseDate !== null) {
+            // TODO: in threetenbp the following line is used, but we dont have Chronology yet,
+            // let chrono = Chronology.from(context.getTemporal());
+            // so let's use IsoChronology for now
+            context.temporal();
+            const chrono = IsoChronology.INSTANCE;
+            baseValue = chrono.date(this._baseDate).get(this._field);
+        }
+        if (value >= baseValue && value < baseValue + EXCEED_POINTS[this._minWidth]) {
+            return absValue % EXCEED_POINTS[this._minWidth];
+        }
+        return absValue % EXCEED_POINTS[this._maxWidth];
+    }
+
+    /**
+     *
+     * @param {DateTimeParseContext} context
+     * @param {number} value
+     * @param {number} errorPos
+     * @param {number} successPos
+     */
+    _setValue(context, value, errorPos, successPos) {
+        let baseValue = this._baseValue;
+        if (this._baseDate != null) {
+            const chrono = context.getEffectiveChronology();
+            baseValue = chrono.date(this._baseDate).get(this._field);
+            // TODO: not implemented??
+            // context.addChronologyChangedParser(this, value, errorPos, successPos);
+        }
+        const parseLen = successPos - errorPos;
+        if (parseLen === this._minWidth && value >= 0) {
+            const range = EXCEED_POINTS[this._minWidth];
+            const lastPart = baseValue % range;
+            const basePart = baseValue - lastPart;
+            if (baseValue > 0) {
+                value = basePart + value;
+            } else {
+                value = basePart - value;
+            }
+            if (value < baseValue) {
+                value += range;
+            }
+        }
+        return context.setParsedField(this._field, value, errorPos, successPos);
+    }
+
+    withFixedWidth() {
+        if (this._subsequentWidth === -1) {
+            return this;
+        }
+        return new ReducedPrinterParser(this._field, this._minWidth, this._maxWidth, this._baseValue, this._baseDate, -1);
+    }
+
+    /**
+     *
+     * @param {number} subsequentWidth
+     * @returns {ReducedPrinterParser}
+     */
+    withSubsequentWidth(subsequentWidth) {
+        return new ReducedPrinterParser(this._field, this._minWidth, this._maxWidth, this._baseValue, this._baseDate,
+            this._subsequentWidth + subsequentWidth);
+    }
+
+    /**
+     *
+     * @param {DateTimeParseContext} context
+     */
+    isFixedWidth(context) {
+        if (context.isStrict() === false) {
+            return false;
+        }
+        return super.isFixedWidth(context);
+    }
+
+    toString() {
+        return 'ReducedValue(' + this._field + ',' + this._minWidth + ',' + this._maxWidth + ',' + (this._baseDate != null ? this._baseDate : this._baseValue) + ')';
+    }
+}
+

package/node_modules/@js-joda/core/src/format/parser/OffsetIdPrinterParser.js

@@ -0,0 +1,177 @@
+/**
+ * @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 {IllegalArgumentException} from '../../errors';
+import {MathUtil} from '../../MathUtil';
+
+import {ChronoField} from '../../temporal/ChronoField';
+
+//-----------------------------------------------------------------------
+const PATTERNS = [
+    '+HH', '+HHmm', '+HH:mm', '+HHMM', '+HH:MM', '+HHMMss', '+HH:MM:ss', '+HHMMSS', '+HH:MM:SS'
+];
+/**
+ * Prints or parses an offset ID.
+ * @private
+ */
+export class OffsetIdPrinterParser  {
+
+    /**
+     * Constructor.
+     *
+     * @param {string} noOffsetText  the text to use for UTC, not null
+     * @param {string} pattern  the pattern
+     */
+    constructor(noOffsetText, pattern) {
+        requireNonNull(noOffsetText, 'noOffsetText');
+        requireNonNull(pattern, 'pattern');
+        this.noOffsetText = noOffsetText;
+        this.type = this._checkPattern(pattern);
+    }
+
+    /**
+     * @param {String} pattern
+     * @return {number}
+     */
+    _checkPattern(pattern) {
+        for (let i = 0; i < PATTERNS.length; i++) {
+            if (PATTERNS[i] === pattern) {
+                return i;
+            }
+        }
+        throw new IllegalArgumentException('Invalid zone offset pattern: ' + pattern);
+    }
+
+    /**
+     * @param {DateTimePrintContext} context
+     * @param {StringBuilder} buf
+     * @return {boolean}
+     */
+    print(context, buf) {
+        const offsetSecs = context.getValue(ChronoField.OFFSET_SECONDS);
+        if (offsetSecs == null) {
+            return false;
+        }
+        const totalSecs = MathUtil.safeToInt(offsetSecs);
+        if (totalSecs === 0) {
+            buf.append(this.noOffsetText);
+        } else {
+            const absHours = Math.abs(MathUtil.intMod(MathUtil.intDiv(totalSecs, 3600), 100));  // anything larger than 99 silently dropped
+            const absMinutes = Math.abs(MathUtil.intMod(MathUtil.intDiv(totalSecs, 60), 60));
+            const absSeconds = Math.abs(MathUtil.intMod(totalSecs, 60));
+            const bufPos = buf.length();
+            let output = absHours;
+            buf.append(totalSecs < 0 ? '-' : '+')
+                .appendChar((MathUtil.intDiv(absHours, 10) + '0')).appendChar(MathUtil.intMod(absHours, 10) + '0');
+            if (this.type >= 3 || (this.type >= 1 && absMinutes > 0)) {
+                buf.append((this.type % 2) === 0 ? ':' : '')
+                    .appendChar((MathUtil.intDiv(absMinutes, 10) + '0')).appendChar((absMinutes % 10 + '0'));
+                output += absMinutes;
+                if (this.type >= 7 || (this.type >= 5 && absSeconds > 0)) {
+                    buf.append((this.type % 2) === 0 ? ':' : '')
+                        .appendChar((MathUtil.intDiv(absSeconds, 10) + '0')).appendChar((absSeconds % 10 + '0'));
+                    output += absSeconds;
+                }
+            }
+            if (output === 0) {
+                buf.setLength(bufPos);
+                buf.append(this.noOffsetText);
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @param {DateTimeParseContext} context
+     * @param {String} text
+     * @param {number} position
+     * @return {number}
+     */
+    parse(context, text, position) {
+        const length = text.length;
+        const noOffsetLen = this.noOffsetText.length;
+        if (noOffsetLen === 0) {
+            if (position === length) {
+                return context.setParsedField(ChronoField.OFFSET_SECONDS, 0, position, position);
+            }
+        } else {
+            if (position === length) {
+                return ~position;
+            }
+            if (context.subSequenceEquals(text, position, this.noOffsetText, 0, noOffsetLen)) {
+                return context.setParsedField(ChronoField.OFFSET_SECONDS, 0, position, position + noOffsetLen);
+            }
+        }
+
+        // parse normal plus/minus offset
+        const sign = text[position];  // IOOBE if invalid position
+        if (sign === '+' || sign === '-') {
+            // starts
+            const negative = (sign === '-' ? -1 : 1);
+            const array = [0,0,0,0];
+            array[0] = position + 1;
+            if ((this._parseNumber(array, 1, text, true) ||
+                this._parseNumber(array, 2, text, this.type >=3) ||
+                this._parseNumber(array, 3, text, false)) === false) {
+                // success
+                const offsetSecs = MathUtil.safeZero(negative * (array[1] * 3600 + array[2] * 60 + array[3]));
+                return context.setParsedField(ChronoField.OFFSET_SECONDS, offsetSecs, position, array[0]);
+            }
+        }
+        // handle special case of empty no offset text
+        if (noOffsetLen === 0) {
+            return context.setParsedField(ChronoField.OFFSET_SECONDS, 0, position, position + noOffsetLen);
+        }
+        return ~position;
+    }
+
+    /**
+     * Parse a two digit zero-prefixed number.
+     *
+     * @param {number[]} array  the array of parsed data, 0=pos,1=hours,2=mins,3=secs, not null
+     * @param {number} arrayIndex  the index to parse the value into
+     * @param {string} parseText  the offset ID, not null
+     * @param {boolean} required  whether this number is required
+     * @return {boolean} true if an error occurred
+     */
+    _parseNumber(array, arrayIndex, parseText, required) {
+        if ((this.type + 3) / 2 < arrayIndex) {
+            return false;  // ignore seconds/minutes
+        }
+        let pos = array[0];
+        if ((this.type % 2) === 0 && arrayIndex > 1) {
+            if (pos + 1 > parseText.length || parseText[pos] !== ':') {
+                return required;
+            }
+            pos++;
+        }
+        if (pos + 2 > parseText.length) {
+            return required;
+        }
+        const ch1 = parseText[pos++];
+        const ch2 = parseText[pos++];
+        if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
+            return required;
+        }
+        const value = (ch1.charCodeAt(0) - 48) * 10 + (ch2.charCodeAt(0) - 48);
+        if (value < 0 || value > 59) {
+            return required;
+        }
+        array[arrayIndex] = value;
+        array[0] = pos;
+        return false;
+    }
+
+
+    toString() {
+        const converted = this.noOffsetText.replace('\'', '\'\'');
+        return 'Offset(' + PATTERNS[this.type] + ',\'' + converted + '\')';
+    }
+}
+OffsetIdPrinterParser.INSTANCE_ID = new OffsetIdPrinterParser('Z', '+HH:MM:ss');
+OffsetIdPrinterParser.PATTERNS = PATTERNS;
+

package/node_modules/@js-joda/core/src/format/parser/PadPrinterParserDecorator.js

@@ -0,0 +1,81 @@
+/**
+ * @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} from '../../errors';
+
+/**
+ * Pads the output to a fixed width.
+ * @private
+ */
+export class PadPrinterParserDecorator {
+
+    /**
+     * Constructor.
+     *
+     * @param printerParser  the printer, not null
+     * @param padWidth  the width to pad to, 1 or greater
+     * @param padChar  the pad character
+     */
+    constructor(printerParser, padWidth, padChar) {
+        // input checked by DateTimeFormatterBuilder
+        this._printerParser = printerParser;
+        this._padWidth = padWidth;
+        this._padChar = padChar;
+    }
+
+    print(context, buf) {
+        const preLen = buf.length();
+        if (this._printerParser.print(context, buf) === false) {
+            return false;
+        }
+        const len = buf.length() - preLen;
+        if (len > this._padWidth) {
+            throw new DateTimeException(
+                `Cannot print as output of ${len} characters exceeds pad width of ${this._padWidth}`);
+        }
+        for (let i = 0; i < this._padWidth - len; i++) {
+            buf.insert(preLen, this._padChar);
+        }
+        return true;
+    }
+
+    parse(context, text, position) {
+        // cache context before changed by decorated parser
+        const strict = context.isStrict();
+        const caseSensitive = context.isCaseSensitive();
+        // parse
+        assert(!(position > text.length));
+        assert(position >= 0);
+        if (position === text.length) {
+            return ~position;  // no more characters in the string
+        }
+        let endPos = position + this._padWidth;
+        if (endPos > text.length) {
+            if (strict) {
+                return ~position;  // not enough characters in the string to meet the parse width
+            }
+            endPos = text.length;
+        }
+        let pos = position;
+        while (pos < endPos &&
+        (caseSensitive ? text[pos] === this._padChar : context.charEquals(text[pos], this._padChar))) {
+            pos++;
+        }
+        text = text.substring(0, endPos);
+        const resultPos = this._printerParser.parse(context, text, pos);
+        if (resultPos !== endPos && strict) {
+            return ~(position + pos);  // parse of decorated field didn't parse to the end
+        }
+        return resultPos;
+    }
+
+    toString() {
+        return `Pad(${this._printerParser},${this._padWidth}${(this._padChar === ' ' ? ')' : ',\'' + this._padChar + '\')')}`;
+    }
+}
+

package/node_modules/@js-joda/core/src/format/parser/SettingsParser.js

@@ -0,0 +1,44 @@
+/**
+ * @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 { Enum } from '../../Enum';
+
+/**
+ * @private
+ */
+export class SettingsParser extends Enum {
+
+    print(/*context, buf*/) {
+        return true;  // nothing to do here
+    }
+
+    parse(context, text, position) {
+        // using ordinals to avoid javac synthetic inner class
+        switch (this) {
+            case SettingsParser.SENSITIVE:   context.setCaseSensitive(true); break;
+            case SettingsParser.INSENSITIVE: context.setCaseSensitive(false); break;
+            case SettingsParser.STRICT:      context.setStrict(true); break;
+            case SettingsParser.LENIENT:     context.setStrict(false); break;
+        }
+        return position;
+    }
+
+    toString() {
+        // using ordinals to avoid javac synthetic inner class
+        switch (this) {
+            case SettingsParser.SENSITIVE:   return 'ParseCaseSensitive(true)';
+            case SettingsParser.INSENSITIVE: return 'ParseCaseSensitive(false)';
+            case SettingsParser.STRICT:      return 'ParseStrict(true)';
+            case SettingsParser.LENIENT:     return 'ParseStrict(false)';
+        }
+    }
+}
+
+SettingsParser.SENSITIVE = new SettingsParser('SENSITIVE');
+SettingsParser.INSENSITIVE = new SettingsParser('INSENSITIVE');
+SettingsParser.STRICT = new SettingsParser('STRICT');
+SettingsParser.LENIENT = new SettingsParser('LENIENT');
+