@attocash/cli 0.1.0

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

@@ -0,0 +1,39 @@
+/**
+ * @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';
+
+/**
+ * Prints or parses a string literal.
+ * @private
+ */
+export class StringLiteralPrinterParser {
+
+    constructor(literal) {
+        this._literal = literal;
+    }
+
+    print(context, buf) {
+        buf.append(this._literal);
+        return true;
+    }
+
+    parse(context, text, position) {
+        const length = text.length;
+        assert(!(position > length || position < 0));
+
+        if (context.subSequenceEquals(text, position, this._literal, 0, this._literal.length) === false) {
+            return ~position;
+        }
+        return position + this._literal.length;
+    }
+
+    toString() {
+        const converted = this._literal.replace("'", "''");
+        return '\'' + converted + '\'';
+    }
+}
+

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

@@ -0,0 +1,218 @@
+/**
+ * @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 {ZoneOffset} from '../../ZoneOffset';
+import {ZoneId} from '../../ZoneId';
+import {ZoneRegion} from '../../ZoneRegion';
+
+import {ChronoField} from '../../temporal/ChronoField';
+
+import { ZoneRulesProvider } from '../../zone/ZoneRulesProvider';
+
+import {OffsetIdPrinterParser} from './OffsetIdPrinterParser';
+
+/**
+ * Prints or parses a zone ID.
+ * @private
+ */
+export class ZoneIdPrinterParser {
+
+    /**
+     *
+     * @param {TemporalQuery} query
+     * @param {string} description
+     */
+    constructor(query, description) {
+        this.query = query;
+        this.description = description;
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     *
+     * @param {DateTimePrintContext } context
+     * @param {StringBuilder} buf
+     * @returns {boolean}
+     */
+    print(context, buf) {
+        const zone = context.getValueQuery(this.query);
+        if (zone == null) {
+            return false;
+        }
+        buf.append(zone.id());
+        return true;
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * This implementation looks for the longest matching string.
+     * For example, parsing Etc/GMT-2 will return Etc/GMC-2 rather than just
+     * Etc/GMC although both are valid.
+     *
+     * This implementation uses a tree to search for valid time-zone names in
+     * the parseText. The top level node of the tree has a length equal to the
+     * length of the shortest time-zone as well as the beginning characters of
+     * all other time-zones.
+     *
+     * @param {DateTimeParseContext} context
+     * @param {String} text
+     * @param {number} position
+     * @return {number}
+     */
+    parse(context, text, position) {
+        const length = text.length;
+        if (position > length) {
+            return ~position;
+        }
+        if (position === length) {
+            return ~position;
+        }
+
+        // handle fixed time-zone IDs
+        const nextChar = text.charAt(position);
+        if (nextChar === '+' || nextChar === '-') {
+            const newContext = context.copy();
+            const endPos = OffsetIdPrinterParser.INSTANCE_ID.parse(newContext, text, position);
+            if (endPos < 0) {
+                return endPos;
+            }
+            const offset = newContext.getParsed(ChronoField.OFFSET_SECONDS);
+            const zone = ZoneOffset.ofTotalSeconds(offset);
+            context.setParsedZone(zone);
+            return endPos;
+        } else if (length >= position + 2) {
+            const nextNextChar = text.charAt(position + 1);
+            if (context.charEquals(nextChar, 'U') &&
+                context.charEquals(nextNextChar, 'T')) {
+                if (length >= position + 3 &&
+                    context.charEquals(text.charAt(position + 2), 'C')) {
+                    return this._parsePrefixedOffset(context, text, position, position + 3);
+                }
+                return this._parsePrefixedOffset(context, text, position, position + 2);
+            } else if (context.charEquals(nextChar, 'G') &&
+                length >= position + 3 &&
+                context.charEquals(nextNextChar, 'M') &&
+                context.charEquals(text.charAt(position + 2), 'T')) {
+                return this._parsePrefixedOffset(context, text, position, position + 3);
+            }
+        }
+        // javascript special case
+        if(text.substr(position, 6) === 'SYSTEM'){
+            context.setParsedZone(ZoneId.systemDefault());
+            return position + 6;
+        }
+
+        // ...
+        if (context.charEquals(nextChar, 'Z')) {
+            context.setParsedZone(ZoneOffset.UTC);
+            return position + 1;
+        }
+
+        const availableZoneIds = ZoneRulesProvider.getAvailableZoneIds();
+        if (zoneIdTree.size !== availableZoneIds.length) {
+            zoneIdTree = ZoneIdTree.createTreeMap(availableZoneIds);
+        }
+
+        const maxParseLength = length - position;
+        let treeMap = zoneIdTree.treeMap;
+        let parsedZoneId = null;
+        let parseLength = 0;
+        while(treeMap != null) {
+            const parsedSubZoneId = text.substr(position, Math.min(treeMap.length, maxParseLength));
+            treeMap = treeMap.get(parsedSubZoneId);
+            if (treeMap != null && treeMap.isLeaf) {
+                parsedZoneId = parsedSubZoneId;
+                parseLength = treeMap.length;
+            }
+        }
+        if (parsedZoneId != null) {
+            context.setParsedZone(ZoneRegion.ofId(parsedZoneId));
+            return position + parseLength;
+        }
+
+        return ~position;
+    }
+
+    /**
+     *
+     * @param {DateTimeParseContext} context
+     * @param {String} text
+     * @param {number} prefixPos
+     * @param {number} position
+     * @return {number}
+     */
+    _parsePrefixedOffset(context, text, prefixPos, position) {
+        const prefix = text.substring(prefixPos, position).toUpperCase();
+        const newContext = context.copy();
+        if (position < text.length && context.charEquals(text.charAt(position), 'Z')) {
+            context.setParsedZone(ZoneId.ofOffset(prefix, ZoneOffset.UTC));
+            return position;
+        }
+        const endPos = OffsetIdPrinterParser.INSTANCE_ID.parse(newContext, text, position);
+        if (endPos < 0) {
+            context.setParsedZone(ZoneId.ofOffset(prefix, ZoneOffset.UTC));
+            return position;
+        }
+        const offsetSecs = newContext.getParsed(ChronoField.OFFSET_SECONDS);
+        const offset = ZoneOffset.ofTotalSeconds(offsetSecs);
+        context.setParsedZone(ZoneId.ofOffset(prefix, offset));
+        return endPos;
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    toString() {
+        return this.description;
+    }
+}
+
+class ZoneIdTree {
+
+    static createTreeMap(availableZoneIds) {
+        const sortedZoneIds =  availableZoneIds.sort((a, b) => a.length - b.length);
+        const treeMap = new ZoneIdTreeMap(sortedZoneIds[0].length, false);
+        for (let i=0; i<sortedZoneIds.length; i++){
+            treeMap.add(sortedZoneIds[i]);
+        }
+        return new ZoneIdTree(sortedZoneIds.length, treeMap);
+    }
+
+    constructor(size, treeMap) {
+        this.size = size;
+        this.treeMap = treeMap;
+    }
+}
+
+class ZoneIdTreeMap {
+    constructor(length = 0, isLeaf = false){
+        this.length = length;
+        this.isLeaf = isLeaf;
+        this._treeMap = {};
+    }
+
+    add(zoneId){
+        const idLength = zoneId.length;
+        if(idLength === this.length) {
+            this._treeMap[zoneId] = new ZoneIdTreeMap(idLength, true);
+        } else if (idLength > this.length) {
+            const subZoneId = zoneId.substr(0, this.length);
+            let subTreeMap = this._treeMap[subZoneId];
+            if (subTreeMap == null) {
+                subTreeMap = new ZoneIdTreeMap(idLength, false);
+                this._treeMap[subZoneId] = subTreeMap;
+            }
+            subTreeMap.add(zoneId);
+        }
+    }
+
+    get(zoneId){
+        return this._treeMap[zoneId];
+    }
+}
+
+let zoneIdTree = new ZoneIdTree([]);

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

@@ -0,0 +1,210 @@
+/**
+ * @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 {
+    ArithmeticException,
+    DateTimeException,
+    DateTimeParseException,
+    IllegalArgumentException,
+    IllegalStateException,
+    UnsupportedTemporalTypeException,
+    NullPointerException
+} from './errors';
+
+import { Clock } from './Clock';
+import { DayOfWeek } from './DayOfWeek';
+import { Duration } from './Duration';
+import { Instant } from './Instant';
+import { LocalDate } from './LocalDate';
+import { LocalTime } from './LocalTime';
+import { LocalDateTime } from './LocalDateTime';
+import { Month } from './Month';
+import { MonthDay } from './MonthDay';
+import { OffsetDateTime } from './OffsetDateTime';
+import { OffsetTime } from './OffsetTime';
+import { Period } from './Period';
+import { Year } from './Year';
+import { YearConstants } from './YearConstants';
+import { YearMonth } from './YearMonth';
+import { ZonedDateTime } from './ZonedDateTime';
+import { ZoneOffset } from './ZoneOffset';
+import { ZoneId } from './ZoneId';
+import { ZoneRegion } from './ZoneRegion';
+
+import { ZoneOffsetTransition } from './zone/ZoneOffsetTransition';
+import { ZoneRules } from './zone/ZoneRules';
+import { ZoneRulesProvider } from './zone/ZoneRulesProvider';
+
+import { ChronoLocalDate } from './chrono/ChronoLocalDate';
+import { ChronoLocalDateTime } from './chrono/ChronoLocalDateTime';
+import { ChronoZonedDateTime } from './chrono/ChronoZonedDateTime';
+import { IsoChronology } from './chrono/IsoChronology';
+
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { IsoFields } from './temporal/IsoFields';
+import { Temporal } from './temporal/Temporal';
+import { TemporalAccessor } from './temporal/TemporalAccessor';
+import { TemporalAdjuster } from './temporal/TemporalAdjuster';
+import { TemporalAdjusters } from './temporal/TemporalAdjusters';
+import { TemporalAmount } from './temporal/TemporalAmount';
+import { TemporalField } from './temporal/TemporalField';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { TemporalQuery } from './temporal/TemporalQuery';
+import { TemporalUnit } from './temporal/TemporalUnit';
+import { ValueRange } from './temporal/ValueRange';
+
+import { DateTimeFormatter } from './format/DateTimeFormatter';
+import { DateTimeFormatterBuilder } from './format/DateTimeFormatterBuilder';
+import { DecimalStyle } from './format/DecimalStyle';
+import { ResolverStyle } from './format/ResolverStyle';
+import { SignStyle } from './format/SignStyle';
+import { TextStyle } from './format/TextStyle';
+
+// init static properties
+import './_init';
+
+// private/internal exports, e.g. for use in plugins
+import { MathUtil } from './MathUtil';
+import { StringUtil } from './StringUtil';
+import { DateTimeBuilder } from './format/DateTimeBuilder';
+import { DateTimeParseContext } from './format/DateTimeParseContext';
+import { DateTimePrintContext } from './format/DateTimePrintContext';
+import { StringBuilder } from './format/StringBuilder';
+import * as assert from './assert';
+
+import { convert } from './convert';
+import { nativeJs } from './temporal/NativeJsTemporal';
+import { bindUse } from './use';
+
+const _ = {
+    assert,
+    DateTimeBuilder,
+    DateTimeParseContext,
+    DateTimePrintContext,
+    MathUtil,
+    StringUtil,
+    StringBuilder,
+};
+
+const jsJodaExports = {
+    _,
+    convert,
+    nativeJs,
+    ArithmeticException,
+    DateTimeException,
+    DateTimeParseException,
+    IllegalArgumentException,
+    IllegalStateException,
+    UnsupportedTemporalTypeException,
+    NullPointerException,
+    Clock,
+    DayOfWeek,
+    Duration,
+    Instant,
+    LocalDate,
+    LocalTime,
+    LocalDateTime,
+    OffsetTime,
+    OffsetDateTime,
+    Month,
+    MonthDay,
+    Period,
+    Year,
+    YearConstants,
+    YearMonth,
+    ZonedDateTime,
+    ZoneOffset,
+    ZoneId,
+    ZoneRegion,
+    ZoneOffsetTransition,
+    ZoneRules,
+    ZoneRulesProvider,
+    ChronoLocalDate,
+    ChronoLocalDateTime,
+    ChronoZonedDateTime,
+    IsoChronology,
+    ChronoField,
+    ChronoUnit,
+    IsoFields,
+    Temporal,
+    TemporalAccessor,
+    TemporalAdjuster,
+    TemporalAdjusters,
+    TemporalAmount,
+    TemporalField,
+    TemporalQueries,
+    TemporalQuery,
+    TemporalUnit,
+    ValueRange,
+    DateTimeFormatter,
+    DateTimeFormatterBuilder,
+    DecimalStyle,
+    ResolverStyle,
+    SignStyle,
+    TextStyle,
+};
+
+const use = bindUse(jsJodaExports);
+jsJodaExports.use = use;
+
+export {
+    _,
+    use,
+    convert,
+    nativeJs,
+    ArithmeticException,
+    DateTimeException,
+    DateTimeParseException,
+    IllegalArgumentException,
+    IllegalStateException,
+    UnsupportedTemporalTypeException,
+    NullPointerException,
+    Clock,
+    DayOfWeek,
+    Duration,
+    Instant,
+    LocalDate,
+    LocalTime,
+    LocalDateTime,
+    Month,
+    MonthDay,
+    OffsetTime,
+    OffsetDateTime,
+    Period,
+    Year,
+    YearConstants,
+    YearMonth,
+    ZonedDateTime,
+    ZoneOffset,
+    ZoneId,
+    ZoneRegion,
+    ZoneOffsetTransition,
+    ZoneRules,
+    ZoneRulesProvider,
+    ChronoLocalDate,
+    ChronoLocalDateTime,
+    ChronoZonedDateTime,
+    IsoChronology,
+    ChronoField,
+    ChronoUnit,
+    IsoFields,
+    Temporal,
+    TemporalAccessor,
+    TemporalAdjuster,
+    TemporalAdjusters,
+    TemporalAmount,
+    TemporalField,
+    TemporalQueries,
+    TemporalQuery,
+    TemporalUnit,
+    ValueRange,
+    DateTimeFormatter,
+    DateTimeFormatterBuilder,
+    DecimalStyle,
+    ResolverStyle,
+    SignStyle,
+    TextStyle,
+};

package/node_modules/@js-joda/core/src/license-preamble.js

@@ -0,0 +1,3 @@
+//! @copyright (c) 2015-present, Philipp Thürwächter, Pattrick Hüper & js-joda contributors
+//! @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+//! @license BSD-3-Clause (see LICENSE in the root directory of this source tree)