@attocash/cli 0.1.0

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

@@ -0,0 +1,248 @@
+import { abstractMethodFail } from '../assert';
+
+/**
+ * @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)
+ */
+
+/**
+ * A field of date-time, such as month-of-year or hour-of-minute.
+ *
+ * Date and time is expressed using fields which partition the time-line into something
+ * meaningful for humans. Implementations of this interface represent those fields.
+ *
+ * The most commonly used units are defined in {@link ChronoField}.
+ * Further fields are supplied in {@link IsoFields}, {@link WeekFields} and {@link JulianFields}.
+ * Fields can also be written by application code by implementing this interface.
+ *
+ * The field works using double dispatch. Client code calls methods on a date-time like
+ * {@link LocalDateTime} which check if the field is a {@link ChronoField}.
+ * 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 TemporalField {
+    /**
+     * Checks if this field represents a component of a date.
+     *
+     * @return {boolean} `true` if it is a component of a date, `false` otherwise.
+     */
+    isDateBased() {
+        abstractMethodFail('isDateBased');
+    }
+
+    /**
+     * Checks if this field represents a component of a time.
+     *
+     * @return {boolean} `true` if it is a component of a time, `false` otherwise.
+     */
+    isTimeBased() {
+        abstractMethodFail('isTimeBased');
+    }
+
+    /**
+     * Gets the unit that the field is measured in.
+     *
+     * The unit of the field is the period that varies within the range.
+     * For example, in the field 'MonthOfYear', the unit is 'Months'.
+     * See also {@link rangeUnit}.
+     *
+     * @return {TemporalUnit} the period unit defining the base unit of the field.
+     */
+    baseUnit() {
+        abstractMethodFail('baseUnit');
+    }
+
+    /**
+     * Gets the range that the field is bound by.
+     * 
+     * The range of the field is the period that the field varies within.
+     * For example, in the field 'MonthOfYear', the range is 'Years'.
+     * See also {@link baseUnit}.
+     * 
+     * The range is never null. For example, the 'Year' field is shorthand for
+     * 'YearOfForever'. It therefore has a unit of 'Years' and a range of 'Forever'.
+     *
+     * @return {TemporalUnit} the period unit defining the range of the field.
+     */
+    rangeUnit() {
+        abstractMethodFail('rangeUnit');
+    }
+
+    /**
+     * Gets the range of valid values for the field.
+     *
+     * All fields can be expressed as an integer.
+     * This method returns an object that describes the valid range for that value.
+     * This method is generally only applicable to the ISO-8601 calendar system.
+     *
+     * Note that the result only describes the minimum and maximum valid values
+     * and it is important not to read too much into them. For example, there
+     * could be values within the range that are invalid for the field.
+     *
+     * @return {ValueRange} the range of valid values for the field.
+     */
+    range() {
+        abstractMethodFail('range');
+    }
+
+    /**
+     * Get the range of valid values for this field using the temporal object to
+     * refine the result.
+     *
+     * This uses the temporal object to find the range of valid values for the field.
+     * This is similar to {@link range}, however this method refines the result
+     * using the temporal. For example, if the field is {@link DAY_OF_MONTH} the
+     * {@link range} method is not accurate as there are four possible month lengths,
+     * 28, 29, 30 and 31 days. Using this method with a date allows the range to be
+     * accurate, returning just one of those four options.
+     *
+     * There are two equivalent ways of using this method.
+     * The first is to invoke this method directly.
+     * The second is to use {@link TemporalAccessor#range}:
+     * <pre>
+     *   // these two lines are equivalent, but the second approach is recommended
+     *   temporal = thisField.rangeRefinedBy(temporal);
+     *   temporal = temporal.range(thisField);
+     * </pre>
+     * It is recommended to use the second approach, {@link range},
+     * as it is a lot clearer to read in code.
+     *
+     * Implementations should perform any queries or calculations using the fields
+     * available in {@link ChronoField}.
+     * If the field is not supported a {@link DateTimeException} must be thrown.
+     *
+     * @param {!TemporalAccessor} temporal the temporal object used to refine the result.
+     * @return {ValueRange} the range of valid values for this field.
+     * @throws {DateTimeException} if the range for the field cannot be obtained.
+     * 
+     */
+    // eslint-disable-next-line no-unused-vars
+    rangeRefinedBy(temporal) {
+        abstractMethodFail('rangeRefinedBy');
+    }
+
+    /**
+     * Gets the value of this field from the specified temporal object.
+     *
+     * This queries the temporal object for the value of this field.
+     *
+     * There are two equivalent ways of using this method.
+     * The first is to invoke this method directly.
+     * The second is to use {@link TemporalAccessor#get}:
+     * <pre>
+     *   // these two lines are equivalent, but the second approach is recommended
+     *   temporal = thisField.getFrom(temporal);
+     *   temporal = temporal.get(thisField);
+     * </pre>
+     * It is recommended to use the second approach, as it is a lot clearer to read in code.
+     *
+     * Implementations should perform any queries or calculations using the fields
+     * available in {@link ChronoField}.
+     * If the field is not supported a {@link DateTimeException} must be thrown.
+     *
+     * @param {!TemporalAccesor} temporal the temporal object to query.
+     * @return {number} the value of this field.
+     * @throws {DateTimeException} if a value for the field cannot be obtained.
+     */
+    // eslint-disable-next-line no-unused-vars
+    getFrom(temporal) {
+        abstractMethodFail('getFrom');
+    }
+
+    /**
+     * Returns a copy of the specified temporal object with the value of this field set.
+     *
+     * This returns a new temporal object based on the specified one with the value for
+     * this field changed. For example, on a {@link LocalDate}, this could be used to
+     * set the year, month or day-of-month.
+     * The returned object has the same observable type as the specified object.
+     *
+     * In some cases, changing a field is not fully defined. For example, if the target object is
+     * a date representing the 31st January, then changing the month to February would be unclear.
+     * In cases like this, the implementation is responsible for resolving the result.
+     * Typically it will choose the previous valid date, which would be the last valid
+     * day of February in this example.
+     *
+     * There are two equivalent ways of using this method.
+     * The first is to invoke this method directly.
+     * The second is to use {@link Temporal#with}:
+     * <pre>
+     *   // these two lines are equivalent, but the second approach is recommended
+     *   temporal = thisField.adjustInto(temporal);
+     *   temporal = temporal.with(thisField);
+     * </pre>
+     * It is recommended to use the second approach, `with(temporal)`,
+     * as it is a lot clearer to read in code.
+     *
+     * Implementations should perform any queries or calculations using 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} temporal the temporal object to adjust.
+     * @param {!number} newValue the new value of the field.
+     * @return {Temporal} the adjusted temporal object.
+     * @throws {DateTimeException} if the field cannot be set.
+     */
+    // eslint-disable-next-line no-unused-vars
+    adjustInto(temporal, newValue) {
+        abstractMethodFail('adjustInto');
+    }
+
+    /**
+     * Checks if this field is supported by the temporal object.
+     *
+     * This determines whether the temporal accessor supports this field.
+     * If this returns false, the the temporal cannot be queried for this field.
+     *
+     * There are two equivalent ways of using this method.
+     * The first is to invoke this method directly.
+     * The second is to use {@link TemporalAccessor#isSupported}:
+     * <pre>
+     *   // these two lines are equivalent, but the second approach is recommended
+     *   temporal = thisField.isSupportedBy(temporal);
+     *   temporal = temporal.isSupported(thisField);
+     * </pre>
+     * It is recommended to use the second approach, `isSupported(temporal)`,
+     * as it is a lot clearer to read in code.
+     *
+     * Implementations should determine whether they are supported using the fields
+     * available in {@link ChronoField}.
+     *
+     * @param {!TemporalAccesor} temporal the temporal object to query.
+     * @return {boolean} `true` if the date-time can be queried for this field, `false` if not.
+     */
+    // eslint-disable-next-line no-unused-vars
+    isSupportedBy(temporal) {
+        abstractMethodFail('isSupportedBy');
+    }
+
+    /**
+     * @return {string}
+     */
+    displayName(/* TODO: locale */) {
+        abstractMethodFail('displayName');
+    }
+
+    /**
+    * @param {*} other
+    * @returns {boolean}
+    */
+    // eslint-disable-next-line no-unused-vars
+    equals(other) {
+        abstractMethodFail('equals');
+    }
+
+    /**
+     * @returns {string}
+     */
+    name() {
+        abstractMethodFail('name');
+    }
+}

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

@@ -0,0 +1,223 @@
+/**
+ * @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)
+ */
+
+/**
+ * Common implementations of {@link TemporalQuery}.
+ *
+ * This class provides common implementations of {@link TemporalQuery}.
+ * These queries are primarily used as optimizations, allowing the internals
+ * of other objects to be extracted effectively. Note that application code
+ * can also use the {@link from} method on most temporal
+ * objects as a method reference matching the query interface, such as
+ * {@link LocalDate::from} and {@link ZoneId::from}.
+ *
+ * There are two equivalent ways of using a {@link TemporalQuery}.
+ * The first is to invoke the method on the interface directly.
+ * The second is to use {@link TemporalAccessor#query}:
+ * <pre>
+ *   // these two lines are equivalent, but the second approach is recommended
+ *   dateTime = query.queryFrom(dateTime);
+ *   dateTime = dateTime.query(query);
+ * </pre>
+ * It is recommended to use the second approach, {@link query},
+ * as it is a lot clearer to read in code.
+ *
+ */
+export class TemporalQueries {
+
+    /**
+     * A strict query for the {@link ZoneId}.
+     *
+     * This queries a {@link TemporalAccessor} for the zone.
+     * The zone is only returned if the date-time conceptually contains a {@link ZoneId}.
+     * It will not be returned if the date-time only conceptually has an {@link ZoneOffset}.
+     * Thus a {@link ZonedDateTime} will return the result of
+     * {@link getZone}, but an {@link OffsetDateTime} will
+     * return null.
+     *
+     * In most cases, applications should use {@link ZONE} as this query is too strict.
+     *
+     * The result from JDK classes implementing {@link TemporalAccessor} is as follows:
+     * * * {@link LocalDate} returns null
+     * * {@link LocalTime} returns null
+     * * {@link LocalDateTime} returns null
+     * * {@link ZonedDateTime} returns the associated zone
+     * * {@link OffsetTime} returns null
+     * * {@link OffsetDateTime} returns null
+     * * {@link ChronoLocalDate} returns null
+     * * {@link ChronoLocalDateTime} returns null
+     * * {@link ChronoZonedDateTime} returns the associated zone
+     * * {@link Era} returns null
+     * * {@link DayOfWeek} returns null
+     * * {@link Month} returns null
+     * * {@link Year} returns null
+     * * {@link YearMonth} returns null
+     * * {@link MonthDay} returns null
+     * * {@link ZoneOffset} returns null
+     * * {@link Instant} returns null
+     *
+     * @return a query that can obtain the zone ID of a temporal, not null
+     */
+    static zoneId() {
+        return TemporalQueries.ZONE_ID;
+    }
+
+    /**
+     * A query for the {@link Chronology}.
+     *
+     * This queries a {@link TemporalAccessor} for the chronology.
+     * If the target {@link TemporalAccessor} represents a date, or part of a date,
+     * then it should return the chronology that the date is expressed in.
+     * As a result of this definition, objects only representing time, such as
+     * {@link LocalTime}, will return null.
+     *
+     * The result from js-joda classes implementing {@link TemporalAccessor} is as follows:
+     *
+     * * {@link LocalDate} returns * {@link IsoChronology.INSTANCE}
+     * * {@link LocalTime} returns null (does not represent a date)
+     * * {@link LocalDateTime} returns * {@link IsoChronology.INSTANCE}
+     * * {@link ZonedDateTime} returns * {@link IsoChronology.INSTANCE}
+     * * {@link OffsetTime} returns null (does not represent a date)
+     * * {@link OffsetDateTime} returns * {@link IsoChronology.INSTANCE}
+     * * {@link ChronoLocalDate} returns the associated chronology
+     * * {@link ChronoLocalDateTime} returns the associated chronology
+     * * {@link ChronoZonedDateTime} returns the associated chronology
+     * * {@link Era} returns the associated chronology
+     * * {@link DayOfWeek} returns null (shared across chronologies)
+     * * {@link Month} returns * {@link IsoChronology.INSTANCE}
+     * * {@link Year} returns * {@link IsoChronology.INSTANCE}
+     * * {@link YearMonth} returns * {@link IsoChronology.INSTANCE}
+     * * {@link MonthDay} returns null * {@link IsoChronology.INSTANCE}
+     * * {@link ZoneOffset} returns null (does not represent a date)
+     * * {@link Instant} returns null (does not represent a date)
+     *
+     * The method {@link Chronology#from} can be used as a
+     * {@link TemporalQuery}
+     * That method is equivalent to this query, except that it throws an
+     * exception if a chronology cannot be obtained.
+     *
+     * @return {TemporalQuery} a query that can obtain the chronology of a temporal, not null
+     */
+    static chronology() {
+        return TemporalQueries.CHRONO;
+    }
+
+    /**
+     * A query for the smallest supported unit.
+     *
+     * This queries a {@link TemporalAccessor} for the time precision.
+     * If the target {@link TemporalAccessor} represents a consistent or complete date-time,
+     * date or time then this must return the smallest precision actually supported.
+     * Note that fields such as {@link NANO_OF_DAY} and {@link NANO_OF_SECOND}
+     * are defined to always return ignoring the precision, thus this is the only
+     * way to find the actual smallest supported unit.
+     * For example, were {@link GregorianCalendar} to implement {@link TemporalAccessor}
+     * it would return a precision of {@link MILLIS}.
+     *
+     * The result from js-joda classes implementing {@link TemporalAccessor} is as follows:
+     *
+     * {@link LocalDate} returns {@link DAYS}
+     * {@link LocalTime} returns {@link NANOS}
+     * {@link LocalDateTime} returns {@link NANOS}
+     * {@link ZonedDateTime} returns {@link NANOS}
+     * {@link OffsetTime} returns {@link NANOS}
+     * {@link OffsetDateTime} returns {@link NANOS}
+     * {@link ChronoLocalDate} returns {@link DAYS}
+     * {@link ChronoLocalDateTime} returns {@link NANOS}
+     * {@link ChronoZonedDateTime} returns {@link NANOS}
+     * {@link Era} returns {@link ERAS}
+     * {@link DayOfWeek} returns {@link DAYS}
+     * {@link Month} returns {@link MONTHS}
+     * {@link Year} returns {@link YEARS}
+     * {@link YearMonth} returns {@link MONTHS}
+     * {@link MonthDay} returns null (does not represent a complete date or time)
+     * {@link ZoneOffset} returns null (does not represent a date or time)
+     * {@link Instant} returns {@link NANOS}
+     *
+     * @return a query that can obtain the precision of a temporal, not null
+     */
+    static precision() {
+        return TemporalQueries.PRECISION;
+    }
+
+    /**
+     * A lenient query for the {@link ZoneId}, falling back to the {@link ZoneOffset}.
+     *
+     * This queries a {@link TemporalAccessor} for the zone.
+     * It first tries to obtain the zone, using {@link zoneId}.
+     * If that is not found it tries to obtain the {@link offset}.
+     *
+     * In most cases, applications should use this query rather than {@link zoneId}.
+     *
+     * This query examines the {@link ChronoField#OFFSET_SECONDS}
+     * field and uses it to create a {@link ZoneOffset}.
+     *
+     * The method {@link ZoneId#from} can be used as a
+     * {@link TemporalQuery} via a method reference, {@link ZoneId::from}.
+     * That method is equivalent to this query, except that it throws an
+     * exception if a zone cannot be obtained.
+     *
+     * @return a query that can obtain the zone ID or offset of a temporal, not null
+     */
+    static zone() {
+        return TemporalQueries.ZONE;
+    }
+
+    /**
+     * A query for {@link ZoneOffset} returning null if not found.
+     *
+     * This returns a {@link TemporalQuery} that can be used to query a temporal
+     * object for the offset. The query will return null if the temporal
+     * object cannot supply an offset.
+     *
+     * The query implementation examines the {@link ChronoField#OFFSET_SECONDS}
+     * field and uses it to create a {@link ZoneOffset}.
+     *
+     * The method {@link java.time.ZoneOffset#from} can be used as a
+     * {@link TemporalQuery} via a method reference, {@link ZoneOffset::from}.
+     * This query and {@link ZoneOffset::from} will return the same result if the
+     * temporal object contains an offset. If the temporal object does not contain
+     * an offset, then the method reference will throw an exception, whereas this
+     * query will return null.
+     *
+     * @return a query that can obtain the offset of a temporal, not null
+     */
+    static offset() {
+        return TemporalQueries.OFFSET;
+    }
+
+    /**
+     * A query for {@link LocalDate} returning null if not found.
+     *
+     * This returns a {@link TemporalQuery} that can be used to query a temporal
+     * object for the local date. The query will return null if the temporal
+     * object cannot supply a local date.
+     *
+     * The query implementation examines the {@link ChronoField#EPOCH_DAY}
+     * field and uses it to create a {@link LocalDate}.
+     *
+     * @return a query that can obtain the date of a temporal, not null
+     */
+    static localDate() {
+        return TemporalQueries.LOCAL_DATE;
+    }
+
+    /**
+     * A query for {@link LocalTime} returning null if not found.
+     *
+     * This returns a {@link TemporalQuery} that can be used to query a temporal
+     * object for the local time. The query will return null if the temporal
+     * object cannot supply a local time.
+     *
+     * The query implementation examines the {@link ChronoField#NANO_OF_DAY}
+     * field and uses it to create a {@link LocalTime}.
+     *
+     * @return a query that can obtain the time of a temporal, not null
+     */
+    static localTime() {
+        return TemporalQueries.LOCAL_TIME;
+    }
+}

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

@@ -0,0 +1,77 @@
+/*
+ * @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 {ChronoField} from './ChronoField';
+import {createTemporalQuery} from './TemporalQuery';
+import {TemporalQueries} from './TemporalQueries';
+
+import {LocalDate} from '../LocalDate';
+import {LocalTime} from '../LocalTime';
+import {ZoneOffset} from '../ZoneOffset';
+
+
+export function _init() {
+    //-----------------------------------------------------------------------
+    /**
+     * A strict query for the {@link ZoneId}.
+     */
+    TemporalQueries.ZONE_ID = createTemporalQuery('ZONE_ID', (temporal) => {
+        return temporal.query(TemporalQueries.ZONE_ID);
+    });
+
+    /**
+     * A query for the {@link Chronology}.
+     */
+    TemporalQueries.CHRONO = createTemporalQuery('CHRONO', (temporal) => {
+        return temporal.query(TemporalQueries.CHRONO);
+    });
+
+    /**
+     * A query for the smallest supported unit.
+     */
+    TemporalQueries.PRECISION = createTemporalQuery('PRECISION', (temporal) => {
+        return temporal.query(TemporalQueries.PRECISION);
+    });
+
+    //-----------------------------------------------------------------------
+    /**
+     * A query for {@link ZoneOffset} returning null if not found.
+     */
+    TemporalQueries.OFFSET = createTemporalQuery('OFFSET', (temporal) => {
+        if (temporal.isSupported(ChronoField.OFFSET_SECONDS)) {
+            return ZoneOffset.ofTotalSeconds(temporal.get(ChronoField.OFFSET_SECONDS));
+        }
+        return null;
+    });
+
+    /**
+     * A lenient query for the {@link ZoneId}, falling back to the {@link ZoneOffset}.
+     */
+    TemporalQueries.ZONE = createTemporalQuery('ZONE', (temporal) => {
+        const zone = temporal.query(TemporalQueries.ZONE_ID);
+        return (zone != null ? zone : temporal.query(TemporalQueries.OFFSET));
+    });
+
+    /**
+     * A query for {@link LocalDate} returning null if not found.
+     */
+    TemporalQueries.LOCAL_DATE = createTemporalQuery('LOCAL_DATE', (temporal) => {
+        if (temporal.isSupported(ChronoField.EPOCH_DAY)) {
+            return LocalDate.ofEpochDay(temporal.getLong(ChronoField.EPOCH_DAY));
+        }
+        return null;
+    });
+
+    /**
+     * A query for {@link LocalTime} returning null if not found.
+     */
+    TemporalQueries.LOCAL_TIME = createTemporalQuery('LOCAL_TIME', (temporal) => {
+        if (temporal.isSupported(ChronoField.NANO_OF_DAY)) {
+            return LocalTime.ofNanoOfDay(temporal.getLong(ChronoField.NANO_OF_DAY));
+        }
+        return null;
+    });
+}

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

@@ -0,0 +1,107 @@
+/*
+ * @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';
+import {Enum} from '../Enum';
+
+
+/**
+ * Strategy for querying a temporal object.
+ *
+ * Queries are a key tool for extracting information from temporal objects.
+ * They exist to externalize the process of querying, permitting different
+ * approaches, as per the strategy design pattern.
+ * Examples might be a query that checks if the date is the day before February 29th
+ * in a leap year, or calculates the number of days to your next birthday.
+ *
+ * The {@link TemporalField} interface provides another mechanism for querying
+ * temporal objects. That interface is limited to returning a `long`.
+ * By contrast, queries can return any type.
+ *
+ * There are two equivalent ways of using a {@link TemporalQuery}.
+ * The first is to invoke the method on this interface directly.
+ * The second is to use {@link TemporalAccessor#query}:
+ * <pre>
+ *   // these two lines are equivalent, but the second approach is recommended
+ *   temporal = thisQuery.queryFrom(temporal);
+ *   temporal = temporal.query(thisQuery);
+ * </pre>
+ * It is recommended to use the second approach, {@link query},
+ * as it is a lot clearer to read in code.
+ *
+ * The most common implementations are method references, such as
+ * {@link LocalDate::from} and {@link ZoneId::from}.
+ * Further implementations are on {@link TemporalQueries}.
+ * Queries may also be defined by applications.
+ *
+ * ### Specification for implementors
+ *
+ * This interface places no restrictions on the mutability of implementations,
+ * however immutability is strongly recommended.
+ *
+ * @interface
+ */
+export class TemporalQuery  extends Enum {
+    /**
+     * Queries the specified temporal object.
+     *
+     * This queries the specified temporal object to return an object using the logic
+     * encapsulated in the implementing class.
+     * Examples might be a query that checks if the date is the day before February 29th
+     * in a leap year, or calculates the number of days to your next birthday.
+     *
+     * There are two equivalent ways of using this method.
+     * The first is to invoke this method directly.
+     * The second is to use {@link TemporalAccessor#query}:
+     * <pre>
+     *   // these two lines are equivalent, but the second approach is recommended
+     *   temporal = thisQuery.queryFrom(temporal);
+     *   temporal = temporal.query(thisQuery);
+     * </pre>
+     * It is recommended to use the second approach, {@link query},
+     * as it is a lot clearer to read in code.
+     *
+     * ### Specification for implementors
+     *
+     * The implementation must take the input object and query it.
+     * The implementation defines the logic of the query and is responsible for
+     * documenting that logic.
+     * It may use any method on {@link TemporalAccessor} to determine the result.
+     * The input object must not be altered.
+     *
+     * The input temporal object may be in a calendar system other than ISO.
+     * Implementations may choose to document compatibility with other calendar systems,
+     * or reject non-ISO temporal objects by querying the chronology (see {@link TemporalQueries#chronology}).
+     *
+     * This method may be called from multiple threads in parallel.
+     * It must be thread-safe when invoked.
+     *
+     * @param {TemporalAccessor} temporal  the temporal object to query, not null
+     * @return the queried value, may return null to indicate not found
+     * @throws DateTimeException if unable to query
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    // eslint-disable-next-line no-unused-vars
+    queryFrom(temporal){
+        abstractMethodFail('queryFrom');
+    }
+
+}
+
+/**
+ * Factory to create something similar to the JSR-310 {TemporalQuery} interface, takes a function and returns a new TemporalQuery object that presents that function
+ * as the queryFrom() function.
+ * @param name for the underlying Enum
+ * @param queryFromFunction
+ */
+export function createTemporalQuery(name, queryFromFunction) {
+    class ExtendedTemporalQuery extends TemporalQuery {
+
+    }
+
+    ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
+    return new ExtendedTemporalQuery(name);
+}