@contrast/agent 3.8.6 → 3.9.3

package/node_modules/moment/src/lib/locale/prototype.js

@@ -10,15 +10,31 @@ import { preParsePostFormat } from './pre-post-format';
 import { relativeTime, pastFuture } from './relative';
 import { set } from './set';
 
-proto.calendar        = calendar;
-proto.longDateFormat  = longDateFormat;
-proto.invalidDate     = invalidDate;
-proto.ordinal         = ordinal;
-proto.preparse        = preParsePostFormat;
-proto.postformat      = preParsePostFormat;
-proto.relativeTime    = relativeTime;
-proto.pastFuture      = pastFuture;
-proto.set             = set;
+proto.calendar = calendar;
+proto.longDateFormat = longDateFormat;
+proto.invalidDate = invalidDate;
+proto.ordinal = ordinal;
+proto.preparse = preParsePostFormat;
+proto.postformat = preParsePostFormat;
+proto.relativeTime = relativeTime;
+proto.pastFuture = pastFuture;
+proto.set = set;
+
+// Eras
+import {
+    localeEras,
+    localeErasParse,
+    localeErasConvertYear,
+    erasAbbrRegex,
+    erasNameRegex,
+    erasNarrowRegex,
+} from '../units/era';
+proto.eras = localeEras;
+proto.erasParse = localeErasParse;
+proto.erasConvertYear = localeErasConvertYear;
+proto.erasAbbrRegex = erasAbbrRegex;
+proto.erasNameRegex = erasNameRegex;
+proto.erasNarrowRegex = erasNarrowRegex;
 
 // Month
 import {
@@ -26,17 +42,21 @@ import {
     localeMonths,
     localeMonthsShort,
     monthsRegex,
-    monthsShortRegex
+    monthsShortRegex,
 } from '../units/month';
 
-proto.months            =        localeMonths;
-proto.monthsShort       =        localeMonthsShort;
-proto.monthsParse       =        localeMonthsParse;
-proto.monthsRegex       = monthsRegex;
-proto.monthsShortRegex  = monthsShortRegex;
+proto.months = localeMonths;
+proto.monthsShort = localeMonthsShort;
+proto.monthsParse = localeMonthsParse;
+proto.monthsRegex = monthsRegex;
+proto.monthsShortRegex = monthsShortRegex;
 
 // Week
-import { localeWeek, localeFirstDayOfYear, localeFirstDayOfWeek } from '../units/week';
+import {
+    localeWeek,
+    localeFirstDayOfYear,
+    localeFirstDayOfWeek,
+} from '../units/week';
 proto.week = localeWeek;
 proto.firstDayOfYear = localeFirstDayOfYear;
 proto.firstDayOfWeek = localeFirstDayOfWeek;
@@ -47,20 +67,19 @@ import {
     localeWeekdays,
     localeWeekdaysMin,
     localeWeekdaysShort,
-
     weekdaysRegex,
     weekdaysShortRegex,
-    weekdaysMinRegex
+    weekdaysMinRegex,
 } from '../units/day-of-week';
 
-proto.weekdays       =        localeWeekdays;
-proto.weekdaysMin    =        localeWeekdaysMin;
-proto.weekdaysShort  =        localeWeekdaysShort;
-proto.weekdaysParse  =        localeWeekdaysParse;
+proto.weekdays = localeWeekdays;
+proto.weekdaysMin = localeWeekdaysMin;
+proto.weekdaysShort = localeWeekdaysShort;
+proto.weekdaysParse = localeWeekdaysParse;
 
-proto.weekdaysRegex       =        weekdaysRegex;
-proto.weekdaysShortRegex  =        weekdaysShortRegex;
-proto.weekdaysMinRegex    =        weekdaysMinRegex;
+proto.weekdaysRegex = weekdaysRegex;
+proto.weekdaysShortRegex = weekdaysShortRegex;
+proto.weekdaysMinRegex = weekdaysMinRegex;
 
 // Hours
 import { localeIsPM, localeMeridiem } from '../units/hour';

package/node_modules/moment/src/lib/locale/relative.js

@@ -1,30 +1,32 @@
 export var defaultRelativeTime = {
-    future : 'in %s',
-    past   : '%s ago',
-    s  : 'a few seconds',
-    ss : '%d seconds',
-    m  : 'a minute',
-    mm : '%d minutes',
-    h  : 'an hour',
-    hh : '%d hours',
-    d  : 'a day',
-    dd : '%d days',
-    M  : 'a month',
-    MM : '%d months',
-    y  : 'a year',
-    yy : '%d years'
+    future: 'in %s',
+    past: '%s ago',
+    s: 'a few seconds',
+    ss: '%d seconds',
+    m: 'a minute',
+    mm: '%d minutes',
+    h: 'an hour',
+    hh: '%d hours',
+    d: 'a day',
+    dd: '%d days',
+    w: 'a week',
+    ww: '%d weeks',
+    M: 'a month',
+    MM: '%d months',
+    y: 'a year',
+    yy: '%d years',
 };
 
 import isFunction from '../utils/is-function';
 
-export function relativeTime (number, withoutSuffix, string, isFuture) {
+export function relativeTime(number, withoutSuffix, string, isFuture) {
     var output = this._relativeTime[string];
-    return (isFunction(output)) ?
-        output(number, withoutSuffix, string, isFuture) :
-        output.replace(/%d/i, number);
+    return isFunction(output)
+        ? output(number, withoutSuffix, string, isFuture)
+        : output.replace(/%d/i, number);
 }
 
-export function pastFuture (diff, output) {
+export function pastFuture(diff, output) {
     var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
     return isFunction(format) ? format(output) : format.replace(/%s/i, output);
 }

package/node_modules/moment/src/lib/locale/set.js

@@ -3,14 +3,16 @@ import extend from '../utils/extend';
 import isObject from '../utils/is-object';
 import hasOwnProp from '../utils/has-own-prop';
 
-export function set (config) {
+export function set(config) {
     var prop, i;
     for (i in config) {
-        prop = config[i];
-        if (isFunction(prop)) {
-            this[i] = prop;
-        } else {
-            this['_' + i] = prop;
+        if (hasOwnProp(config, i)) {
+            prop = config[i];
+            if (isFunction(prop)) {
+                this[i] = prop;
+            } else {
+                this['_' + i] = prop;
+            }
         }
     }
     this._config = config;
@@ -19,11 +21,14 @@ export function set (config) {
     // TODO: Remove "ordinalParse" fallback in next major release.
     this._dayOfMonthOrdinalParseLenient = new RegExp(
         (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
-            '|' + (/\d{1,2}/).source);
+            '|' +
+            /\d{1,2}/.source
+    );
 }
 
 export function mergeConfigs(parentConfig, childConfig) {
-    var res = extend({}, parentConfig), prop;
+    var res = extend({}, parentConfig),
+        prop;
     for (prop in childConfig) {
         if (hasOwnProp(childConfig, prop)) {
             if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
@@ -38,9 +43,11 @@ export function mergeConfigs(parentConfig, childConfig) {
         }
     }
     for (prop in parentConfig) {
-        if (hasOwnProp(parentConfig, prop) &&
-                !hasOwnProp(childConfig, prop) &&
-                isObject(parentConfig[prop])) {
+        if (
+            hasOwnProp(parentConfig, prop) &&
+            !hasOwnProp(childConfig, prop) &&
+            isObject(parentConfig[prop])
+        ) {
             // make sure changes to properties don't modify parent config
             res[prop] = extend({}, res[prop]);
         }

package/node_modules/moment/src/lib/moment/add-subtract.js

@@ -5,26 +5,33 @@ import { deprecateSimple } from '../utils/deprecate';
 import { hooks } from '../utils/hooks';
 import absRound from '../utils/abs-round';
 
-
 // TODO: remove 'name' arg after deprecation is removed
 function createAdder(direction, name) {
     return function (val, period) {
         var dur, tmp;
         //invert the arguments, but complain about it
         if (period !== null && !isNaN(+period)) {
-            deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
-            'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
-            tmp = val; val = period; period = tmp;
+            deprecateSimple(
+                name,
+                'moment().' +
+                    name +
+                    '(period, number) is deprecated. Please use moment().' +
+                    name +
+                    '(number, period). ' +
+                    'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'
+            );
+            tmp = val;
+            val = period;
+            period = tmp;
         }
 
-        val = typeof val === 'string' ? +val : val;
         dur = createDuration(val, period);
         addSubtract(this, dur, direction);
         return this;
     };
 }
 
-export function addSubtract (mom, duration, isAdding, updateOffset) {
+export function addSubtract(mom, duration, isAdding, updateOffset) {
     var milliseconds = duration._milliseconds,
         days = absRound(duration._days),
         months = absRound(duration._months);
@@ -50,6 +57,5 @@ export function addSubtract (mom, duration, isAdding, updateOffset) {
     }
 }
 
-export var add      = createAdder(1, 'add');
-export var subtract = createAdder(-1, 'subtract');
-
+export var add = createAdder(1, 'add'),
+    subtract = createAdder(-1, 'subtract');

package/node_modules/moment/src/lib/moment/calendar.js

@@ -2,25 +2,52 @@ import { createLocal } from '../create/local';
 import { cloneWithOffset } from '../units/offset';
 import isFunction from '../utils/is-function';
 import { hooks } from '../utils/hooks';
+import { isMomentInput } from '../utils/is-moment-input';
+import isCalendarSpec from '../utils/is-calendar-spec';
 
 export function getCalendarFormat(myMoment, now) {
     var diff = myMoment.diff(now, 'days', true);
-    return diff < -6 ? 'sameElse' :
-            diff < -1 ? 'lastWeek' :
-            diff < 0 ? 'lastDay' :
-            diff < 1 ? 'sameDay' :
-            diff < 2 ? 'nextDay' :
-            diff < 7 ? 'nextWeek' : 'sameElse';
+    return diff < -6
+        ? 'sameElse'
+        : diff < -1
+        ? 'lastWeek'
+        : diff < 0
+        ? 'lastDay'
+        : diff < 1
+        ? 'sameDay'
+        : diff < 2
+        ? 'nextDay'
+        : diff < 7
+        ? 'nextWeek'
+        : 'sameElse';
 }
 
-export function calendar (time, formats) {
+export function calendar(time, formats) {
+    // Support for single parameter, formats only overload to the calendar function
+    if (arguments.length === 1) {
+        if (!arguments[0]) {
+            time = undefined;
+            formats = undefined;
+        } else if (isMomentInput(arguments[0])) {
+            time = arguments[0];
+            formats = undefined;
+        } else if (isCalendarSpec(arguments[0])) {
+            formats = arguments[0];
+            time = undefined;
+        }
+    }
     // We want to compare the start of today, vs this.
     // Getting start-of-today depends on whether we're local/utc/offset or not.
     var now = time || createLocal(),
         sod = cloneWithOffset(now, this).startOf('day'),
-        format = hooks.calendarFormat(this, sod) || 'sameElse';
+        format = hooks.calendarFormat(this, sod) || 'sameElse',
+        output =
+            formats &&
+            (isFunction(formats[format])
+                ? formats[format].call(this, now)
+                : formats[format]);
 
-    var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
-
-    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
+    return this.format(
+        output || this.localeData().calendar(format, this, createLocal(now))
+    );
 }

package/node_modules/moment/src/lib/moment/clone.js

@@ -1,5 +1,5 @@
 import { Moment } from './constructor';
 
-export function clone () {
+export function clone() {
     return new Moment(this);
 }

package/node_modules/moment/src/lib/moment/compare.js

@@ -2,7 +2,7 @@ import { isMoment } from './constructor';
 import { normalizeUnits } from '../units/aliases';
 import { createLocal } from '../create/local';
 
-export function isAfter (input, units) {
+export function isAfter(input, units) {
     var localInput = isMoment(input) ? input : createLocal(input);
     if (!(this.isValid() && localInput.isValid())) {
         return false;
@@ -15,7 +15,7 @@ export function isAfter (input, units) {
     }
 }
 
-export function isBefore (input, units) {
+export function isBefore(input, units) {
     var localInput = isMoment(input) ? input : createLocal(input);
     if (!(this.isValid() && localInput.isValid())) {
         return false;
@@ -28,18 +28,24 @@ export function isBefore (input, units) {
     }
 }
 
-export function isBetween (from, to, units, inclusivity) {
+export function isBetween(from, to, units, inclusivity) {
     var localFrom = isMoment(from) ? from : createLocal(from),
         localTo = isMoment(to) ? to : createLocal(to);
     if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
         return false;
     }
     inclusivity = inclusivity || '()';
-    return (inclusivity[0] === '(' ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) &&
-        (inclusivity[1] === ')' ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
+    return (
+        (inclusivity[0] === '('
+            ? this.isAfter(localFrom, units)
+            : !this.isBefore(localFrom, units)) &&
+        (inclusivity[1] === ')'
+            ? this.isBefore(localTo, units)
+            : !this.isAfter(localTo, units))
+    );
 }
 
-export function isSame (input, units) {
+export function isSame(input, units) {
     var localInput = isMoment(input) ? input : createLocal(input),
         inputMs;
     if (!(this.isValid() && localInput.isValid())) {
@@ -50,14 +56,17 @@ export function isSame (input, units) {
         return this.valueOf() === localInput.valueOf();
     } else {
         inputMs = localInput.valueOf();
-        return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
+        return (
+            this.clone().startOf(units).valueOf() <= inputMs &&
+            inputMs <= this.clone().endOf(units).valueOf()
+        );
     }
 }
 
-export function isSameOrAfter (input, units) {
+export function isSameOrAfter(input, units) {
     return this.isSame(input, units) || this.isAfter(input, units);
 }
 
-export function isSameOrBefore (input, units) {
+export function isSameOrBefore(input, units) {
     return this.isSame(input, units) || this.isBefore(input, units);
 }

package/node_modules/moment/src/lib/moment/constructor.js

@@ -1,11 +1,11 @@
 import { hooks } from '../utils/hooks';
-import hasOwnProp from '../utils/has-own-prop';
 import isUndefined from '../utils/is-undefined';
 import getParsingFlags from '../create/parsing-flags';
 
 // Plugins that add properties should also add the key here (null value),
 // so we can properly clone ourselves.
-var momentProperties = hooks.momentProperties = [];
+var momentProperties = (hooks.momentProperties = []),
+    updateInProgress = false;
 
 export function copyConfig(to, from) {
     var i, prop, val;
@@ -54,8 +54,6 @@ export function copyConfig(to, from) {
     return to;
 }
 
-var updateInProgress = false;
-
 // Moment prototype object
 export function Moment(config) {
     copyConfig(this, config);
@@ -72,6 +70,8 @@ export function Moment(config) {
     }
 }
 
-export function isMoment (obj) {
-    return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
+export function isMoment(obj) {
+    return (
+        obj instanceof Moment || (obj != null && obj._isAMomentObject != null)
+    );
 }

package/node_modules/moment/src/lib/moment/creation-data.js

@@ -4,6 +4,6 @@ export function creationData() {
         format: this._f,
         locale: this._locale,
         isUTC: this._isUTC,
-        strict: this._strict
+        strict: this._strict,
     };
 }

package/node_modules/moment/src/lib/moment/diff.js

@@ -2,10 +2,8 @@ import absFloor from '../utils/abs-floor';
 import { cloneWithOffset } from '../units/offset';
 import { normalizeUnits } from '../units/aliases';
 
-export function diff (input, units, asFloat) {
-    var that,
-        zoneDelta,
-        delta, output;
+export function diff(input, units, asFloat) {
+    var that, zoneDelta, output;
 
     if (!this.isValid()) {
         return NaN;
@@ -22,26 +20,49 @@ export function diff (input, units, asFloat) {
     units = normalizeUnits(units);
 
     switch (units) {
-        case 'year': output = monthDiff(this, that) / 12; break;
-        case 'month': output = monthDiff(this, that); break;
-        case 'quarter': output = monthDiff(this, that) / 3; break;
-        case 'second': output = (this - that) / 1e3; break; // 1000
-        case 'minute': output = (this - that) / 6e4; break; // 1000 * 60
-        case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60
-        case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst
-        case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst
-        default: output = this - that;
+        case 'year':
+            output = monthDiff(this, that) / 12;
+            break;
+        case 'month':
+            output = monthDiff(this, that);
+            break;
+        case 'quarter':
+            output = monthDiff(this, that) / 3;
+            break;
+        case 'second':
+            output = (this - that) / 1e3;
+            break; // 1000
+        case 'minute':
+            output = (this - that) / 6e4;
+            break; // 1000 * 60
+        case 'hour':
+            output = (this - that) / 36e5;
+            break; // 1000 * 60 * 60
+        case 'day':
+            output = (this - that - zoneDelta) / 864e5;
+            break; // 1000 * 60 * 60 * 24, negate dst
+        case 'week':
+            output = (this - that - zoneDelta) / 6048e5;
+            break; // 1000 * 60 * 60 * 24 * 7, negate dst
+        default:
+            output = this - that;
     }
 
     return asFloat ? output : absFloor(output);
 }
 
-function monthDiff (a, b) {
+function monthDiff(a, b) {
+    if (a.date() < b.date()) {
+        // end-of-month calculations work correct when the start month has more
+        // days than the end month.
+        return -monthDiff(b, a);
+    }
     // difference in months
-    var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
+    var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()),
         // b is in (anchor - 1 month, anchor + 1 month)
         anchor = a.clone().add(wholeMonthDiff, 'months'),
-        anchor2, adjust;
+        anchor2,
+        adjust;
 
     if (b - anchor < 0) {
         anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');

package/node_modules/moment/src/lib/moment/format.js

@@ -5,7 +5,7 @@ import isFunction from '../utils/is-function';
 hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
 hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
 
-export function toString () {
+export function toString() {
     return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
 }
 
@@ -13,20 +13,30 @@ export function toISOString(keepOffset) {
     if (!this.isValid()) {
         return null;
     }
-    var utc = keepOffset !== true;
-    var m = utc ? this.clone().utc() : this;
+    var utc = keepOffset !== true,
+        m = utc ? this.clone().utc() : this;
     if (m.year() < 0 || m.year() > 9999) {
-        return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');
+        return formatMoment(
+            m,
+            utc
+                ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'
+                : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'
+        );
     }
     if (isFunction(Date.prototype.toISOString)) {
         // native implementation is ~50x faster, use it when we can
         if (utc) {
             return this.toDate().toISOString();
         } else {
-            return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z'));
+            return new Date(this.valueOf() + this.utcOffset() * 60 * 1000)
+                .toISOString()
+                .replace('Z', formatMoment(m, 'Z'));
         }
     }
-    return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');
+    return formatMoment(
+        m,
+        utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'
+    );
 }
 
 /**
@@ -35,27 +45,33 @@ export function toISOString(keepOffset) {
  *
  * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
  */
-export function inspect () {
+export function inspect() {
     if (!this.isValid()) {
         return 'moment.invalid(/* ' + this._i + ' */)';
     }
-    var func = 'moment';
-    var zone = '';
+    var func = 'moment',
+        zone = '',
+        prefix,
+        year,
+        datetime,
+        suffix;
     if (!this.isLocal()) {
         func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
         zone = 'Z';
     }
-    var prefix = '[' + func + '("]';
-    var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
-    var datetime = '-MM-DD[T]HH:mm:ss.SSS';
-    var suffix = zone + '[")]';
+    prefix = '[' + func + '("]';
+    year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY';
+    datetime = '-MM-DD[T]HH:mm:ss.SSS';
+    suffix = zone + '[")]';
 
     return this.format(prefix + year + datetime + suffix);
 }
 
-export function format (inputString) {
+export function format(inputString) {
     if (!inputString) {
-        inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
+        inputString = this.isUtc()
+            ? hooks.defaultFormatUtc
+            : hooks.defaultFormat;
     }
     var output = formatMoment(this, inputString);
     return this.localeData().postformat(output);

package/node_modules/moment/src/lib/moment/from.js

@@ -2,16 +2,19 @@ import { createDuration } from '../duration/create';
 import { createLocal } from '../create/local';
 import { isMoment } from '../moment/constructor';
 
-export function from (time, withoutSuffix) {
-    if (this.isValid() &&
-            ((isMoment(time) && time.isValid()) ||
-             createLocal(time).isValid())) {
-        return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
+export function from(time, withoutSuffix) {
+    if (
+        this.isValid() &&
+        ((isMoment(time) && time.isValid()) || createLocal(time).isValid())
+    ) {
+        return createDuration({ to: this, from: time })
+            .locale(this.locale())
+            .humanize(!withoutSuffix);
     } else {
         return this.localeData().invalidDate();
     }
 }
 
-export function fromNow (withoutSuffix) {
+export function fromNow(withoutSuffix) {
     return this.from(createLocal(), withoutSuffix);
 }