@contrast/agent 3.8.5 → 3.9.2

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

@@ -2,7 +2,7 @@ import { normalizeObjectUnits } from '../units/aliases';
 import { getLocale } from '../locale/locales';
 import isDurationValid from './valid.js';
 
-export function Duration (duration) {
+export function Duration(duration) {
     var normalizedInput = normalizeObjectUnits(duration),
         years = normalizedInput.year || 0,
         quarters = normalizedInput.quarter || 0,
@@ -17,20 +17,18 @@ export function Duration (duration) {
     this._isValid = isDurationValid(normalizedInput);
 
     // representation for dateAddRemove
-    this._milliseconds = +milliseconds +
+    this._milliseconds =
+        +milliseconds +
         seconds * 1e3 + // 1000
         minutes * 6e4 + // 1000 * 60
         hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
     // Because of dateAddRemove treats 24 hours as different from a
     // day when working around DST, we need to store them separately
-    this._days = +days +
-        weeks * 7;
+    this._days = +days + weeks * 7;
     // It is impossible to translate months into days without knowing
     // which months you are are talking about, so we have to store
     // it separately.
-    this._months = +months +
-        quarters * 3 +
-        years * 12;
+    this._months = +months + quarters * 3 + years * 12;
 
     this._data = {};
 
@@ -39,6 +37,6 @@ export function Duration (duration) {
     this._bubble();
 }
 
-export function isDuration (obj) {
+export function isDuration(obj) {
     return obj instanceof Duration;
 }

package/node_modules/moment/src/lib/duration/create.js

@@ -9,14 +9,13 @@ import { createLocal } from '../create/local';
 import { createInvalid as invalid } from './valid';
 
 // ASP.NET json date format regex
-var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
+var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,
+    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
+    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
+    // and further modified to allow for strings containing both week and day
+    isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
 
-// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
-// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
-// and further modified to allow for strings containing both week and day
-var isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
-
-export function createDuration (input, key) {
+export function createDuration(input, key) {
     var duration = input,
         // matching against regexp is expensive, do it on demand
         match = null,
@@ -26,42 +25,49 @@ export function createDuration (input, key) {
 
     if (isDuration(input)) {
         duration = {
-            ms : input._milliseconds,
-            d  : input._days,
-            M  : input._months
+            ms: input._milliseconds,
+            d: input._days,
+            M: input._months,
         };
-    } else if (isNumber(input)) {
+    } else if (isNumber(input) || !isNaN(+input)) {
         duration = {};
         if (key) {
-            duration[key] = input;
+            duration[key] = +input;
         } else {
-            duration.milliseconds = input;
+            duration.milliseconds = +input;
         }
-    } else if (!!(match = aspNetRegex.exec(input))) {
-        sign = (match[1] === '-') ? -1 : 1;
+    } else if ((match = aspNetRegex.exec(input))) {
+        sign = match[1] === '-' ? -1 : 1;
         duration = {
-            y  : 0,
-            d  : toInt(match[DATE])                         * sign,
-            h  : toInt(match[HOUR])                         * sign,
-            m  : toInt(match[MINUTE])                       * sign,
-            s  : toInt(match[SECOND])                       * sign,
-            ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
+            y: 0,
+            d: toInt(match[DATE]) * sign,
+            h: toInt(match[HOUR]) * sign,
+            m: toInt(match[MINUTE]) * sign,
+            s: toInt(match[SECOND]) * sign,
+            ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match
         };
-    } else if (!!(match = isoRegex.exec(input))) {
-        sign = (match[1] === '-') ? -1 : 1;
+    } else if ((match = isoRegex.exec(input))) {
+        sign = match[1] === '-' ? -1 : 1;
         duration = {
-            y : parseIso(match[2], sign),
-            M : parseIso(match[3], sign),
-            w : parseIso(match[4], sign),
-            d : parseIso(match[5], sign),
-            h : parseIso(match[6], sign),
-            m : parseIso(match[7], sign),
-            s : parseIso(match[8], sign)
+            y: parseIso(match[2], sign),
+            M: parseIso(match[3], sign),
+            w: parseIso(match[4], sign),
+            d: parseIso(match[5], sign),
+            h: parseIso(match[6], sign),
+            m: parseIso(match[7], sign),
+            s: parseIso(match[8], sign),
         };
-    } else if (duration == null) {// checks for null or undefined
+    } else if (duration == null) {
+        // checks for null or undefined
         duration = {};
-    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
-        diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
+    } else if (
+        typeof duration === 'object' &&
+        ('from' in duration || 'to' in duration)
+    ) {
+        diffRes = momentsDifference(
+            createLocal(duration.from),
+            createLocal(duration.to)
+        );
 
         duration = {};
         duration.ms = diffRes.milliseconds;
@@ -74,13 +80,17 @@ export function createDuration (input, key) {
         ret._locale = input._locale;
     }
 
+    if (isDuration(input) && hasOwnProp(input, '_isValid')) {
+        ret._isValid = input._isValid;
+    }
+
     return ret;
 }
 
 createDuration.fn = Duration.prototype;
 createDuration.invalid = invalid;
 
-function parseIso (inp, sign) {
+function parseIso(inp, sign) {
     // We'd normally use ~~inp for this, but unfortunately it also
     // converts floats to ints.
     // inp may be undefined, so careful calling replace on it.
@@ -92,13 +102,13 @@ function parseIso (inp, sign) {
 function positiveMomentsDifference(base, other) {
     var res = {};
 
-    res.months = other.month() - base.month() +
-        (other.year() - base.year()) * 12;
+    res.months =
+        other.month() - base.month() + (other.year() - base.year()) * 12;
     if (base.clone().add(res.months, 'M').isAfter(other)) {
         --res.months;
     }
 
-    res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
+    res.milliseconds = +other - +base.clone().add(res.months, 'M');
 
     return res;
 }
@@ -106,7 +116,7 @@ function positiveMomentsDifference(base, other) {
 function momentsDifference(base, other) {
     var res;
     if (!(base.isValid() && other.isValid())) {
-        return {milliseconds: 0, months: 0};
+        return { milliseconds: 0, months: 0 };
     }
 
     other = cloneWithOffset(other, base);

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

@@ -5,12 +5,12 @@ import { createDuration } from './create';
 import { isDuration } from './constructor';
 import {
     getSetRelativeTimeRounding,
-    getSetRelativeTimeThreshold
+    getSetRelativeTimeThreshold,
 } from './humanize';
 
 export {
     createDuration,
     isDuration,
     getSetRelativeTimeRounding,
-    getSetRelativeTimeThreshold
+    getSetRelativeTimeThreshold,
 };

package/node_modules/moment/src/lib/duration/get.js

@@ -1,7 +1,7 @@
 import { normalizeUnits } from '../units/aliases';
 import absFloor from '../utils/abs-floor';
 
-export function get (units) {
+export function get(units) {
     units = normalizeUnits(units);
     return this.isValid() ? this[units + 's']() : NaN;
 }
@@ -12,14 +12,16 @@ function makeGetter(name) {
     };
 }
 
-export var milliseconds = makeGetter('milliseconds');
-export var seconds      = makeGetter('seconds');
-export var minutes      = makeGetter('minutes');
-export var hours        = makeGetter('hours');
-export var days         = makeGetter('days');
-export var months       = makeGetter('months');
-export var years        = makeGetter('years');
+var milliseconds = makeGetter('milliseconds'),
+    seconds = makeGetter('seconds'),
+    minutes = makeGetter('minutes'),
+    hours = makeGetter('hours'),
+    days = makeGetter('days'),
+    months = makeGetter('months'),
+    years = makeGetter('years');
 
-export function weeks () {
+export { milliseconds, seconds, minutes, hours, days, months, years };
+
+export function weeks() {
     return absFloor(this.days() / 7);
 }

package/node_modules/moment/src/lib/duration/humanize.js

@@ -1,40 +1,50 @@
 import { createDuration } from './create';
 
-var round = Math.round;
-var thresholds = {
-    ss: 44,         // a few seconds to seconds
-    s : 45,         // seconds to minute
-    m : 45,         // minutes to hour
-    h : 22,         // hours to day
-    d : 26,         // days to month
-    M : 11          // months to year
-};
+var round = Math.round,
+    thresholds = {
+        ss: 44, // a few seconds to seconds
+        s: 45, // seconds to minute
+        m: 45, // minutes to hour
+        h: 22, // hours to day
+        d: 26, // days to month/week
+        w: null, // weeks to month
+        M: 11, // months to year
+    };
 
 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
 function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
     return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
 }
 
-function relativeTime (posNegDuration, withoutSuffix, locale) {
-    var duration = createDuration(posNegDuration).abs();
-    var seconds  = round(duration.as('s'));
-    var minutes  = round(duration.as('m'));
-    var hours    = round(duration.as('h'));
-    var days     = round(duration.as('d'));
-    var months   = round(duration.as('M'));
-    var years    = round(duration.as('y'));
+function relativeTime(posNegDuration, withoutSuffix, thresholds, locale) {
+    var duration = createDuration(posNegDuration).abs(),
+        seconds = round(duration.as('s')),
+        minutes = round(duration.as('m')),
+        hours = round(duration.as('h')),
+        days = round(duration.as('d')),
+        months = round(duration.as('M')),
+        weeks = round(duration.as('w')),
+        years = round(duration.as('y')),
+        a =
+            (seconds <= thresholds.ss && ['s', seconds]) ||
+            (seconds < thresholds.s && ['ss', seconds]) ||
+            (minutes <= 1 && ['m']) ||
+            (minutes < thresholds.m && ['mm', minutes]) ||
+            (hours <= 1 && ['h']) ||
+            (hours < thresholds.h && ['hh', hours]) ||
+            (days <= 1 && ['d']) ||
+            (days < thresholds.d && ['dd', days]);
 
-    var a = seconds <= thresholds.ss && ['s', seconds]  ||
-            seconds < thresholds.s   && ['ss', seconds] ||
-            minutes <= 1             && ['m']           ||
-            minutes < thresholds.m   && ['mm', minutes] ||
-            hours   <= 1             && ['h']           ||
-            hours   < thresholds.h   && ['hh', hours]   ||
-            days    <= 1             && ['d']           ||
-            days    < thresholds.d   && ['dd', days]    ||
-            months  <= 1             && ['M']           ||
-            months  < thresholds.M   && ['MM', months]  ||
-            years   <= 1             && ['y']           || ['yy', years];
+    if (thresholds.w != null) {
+        a =
+            a ||
+            (weeks <= 1 && ['w']) ||
+            (weeks < thresholds.w && ['ww', weeks]);
+    }
+    a = a ||
+        (months <= 1 && ['M']) ||
+        (months < thresholds.M && ['MM', months]) ||
+        (years <= 1 && ['y']) || ['yy', years];
 
     a[2] = withoutSuffix;
     a[3] = +posNegDuration > 0;
@@ -43,11 +53,11 @@ function relativeTime (posNegDuration, withoutSuffix, locale) {
 }
 
 // This function allows you to set the rounding function for relative time strings
-export function getSetRelativeTimeRounding (roundingFunction) {
+export function getSetRelativeTimeRounding(roundingFunction) {
     if (roundingFunction === undefined) {
         return round;
     }
-    if (typeof(roundingFunction) === 'function') {
+    if (typeof roundingFunction === 'function') {
         round = roundingFunction;
         return true;
     }
@@ -55,7 +65,7 @@ export function getSetRelativeTimeRounding (roundingFunction) {
 }
 
 // This function allows you to set a threshold for relative time strings
-export function getSetRelativeTimeThreshold (threshold, limit) {
+export function getSetRelativeTimeThreshold(threshold, limit) {
     if (thresholds[threshold] === undefined) {
         return false;
     }
@@ -69,13 +79,32 @@ export function getSetRelativeTimeThreshold (threshold, limit) {
     return true;
 }
 
-export function humanize (withSuffix) {
+export function humanize(argWithSuffix, argThresholds) {
     if (!this.isValid()) {
         return this.localeData().invalidDate();
     }
 
-    var locale = this.localeData();
-    var output = relativeTime(this, !withSuffix, locale);
+    var withSuffix = false,
+        th = thresholds,
+        locale,
+        output;
+
+    if (typeof argWithSuffix === 'object') {
+        argThresholds = argWithSuffix;
+        argWithSuffix = false;
+    }
+    if (typeof argWithSuffix === 'boolean') {
+        withSuffix = argWithSuffix;
+    }
+    if (typeof argThresholds === 'object') {
+        th = Object.assign({}, thresholds, argThresholds);
+        if (argThresholds.s != null && argThresholds.ss == null) {
+            th.ss = argThresholds.s - 1;
+        }
+    }
+
+    locale = this.localeData();
+    output = relativeTime(this, !withSuffix, th, locale);
 
     if (withSuffix) {
         output = locale.pastFuture(+this, output);

package/node_modules/moment/src/lib/duration/iso-string.js

@@ -2,7 +2,7 @@ import absFloor from '../utils/abs-floor';
 var abs = Math.abs;
 
 function sign(x) {
-    return ((x > 0) - (x < 0)) || +x;
+    return (x > 0) - (x < 0) || +x;
 }
 
 export function toISOString() {
@@ -17,48 +17,52 @@ export function toISOString() {
         return this.localeData().invalidDate();
     }
 
-    var seconds = abs(this._milliseconds) / 1000;
-    var days         = abs(this._days);
-    var months       = abs(this._months);
-    var minutes, hours, years;
+    var seconds = abs(this._milliseconds) / 1000,
+        days = abs(this._days),
+        months = abs(this._months),
+        minutes,
+        hours,
+        years,
+        s,
+        total = this.asSeconds(),
+        totalSign,
+        ymSign,
+        daysSign,
+        hmsSign;
+
+    if (!total) {
+        // this is the same as C#'s (Noda) and python (isodate)...
+        // but not other JS (goog.date)
+        return 'P0D';
+    }
 
     // 3600 seconds -> 60 minutes -> 1 hour
-    minutes           = absFloor(seconds / 60);
-    hours             = absFloor(minutes / 60);
+    minutes = absFloor(seconds / 60);
+    hours = absFloor(minutes / 60);
     seconds %= 60;
     minutes %= 60;
 
     // 12 months -> 1 year
-    years  = absFloor(months / 12);
+    years = absFloor(months / 12);
     months %= 12;
 
-
     // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
-    var Y = years;
-    var M = months;
-    var D = days;
-    var h = hours;
-    var m = minutes;
-    var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
-    var total = this.asSeconds();
-
-    if (!total) {
-        // this is the same as C#'s (Noda) and python (isodate)...
-        // but not other JS (goog.date)
-        return 'P0D';
-    }
+    s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
 
-    var totalSign = total < 0 ? '-' : '';
-    var ymSign = sign(this._months) !== sign(total) ? '-' : '';
-    var daysSign = sign(this._days) !== sign(total) ? '-' : '';
-    var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
+    totalSign = total < 0 ? '-' : '';
+    ymSign = sign(this._months) !== sign(total) ? '-' : '';
+    daysSign = sign(this._days) !== sign(total) ? '-' : '';
+    hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
 
-    return totalSign + 'P' +
-        (Y ? ymSign + Y + 'Y' : '') +
-        (M ? ymSign + M + 'M' : '') +
-        (D ? daysSign + D + 'D' : '') +
-        ((h || m || s) ? 'T' : '') +
-        (h ? hmsSign + h + 'H' : '') +
-        (m ? hmsSign + m + 'M' : '') +
-        (s ? hmsSign + s + 'S' : '');
+    return (
+        totalSign +
+        'P' +
+        (years ? ymSign + years + 'Y' : '') +
+        (months ? ymSign + months + 'M' : '') +
+        (days ? daysSign + days + 'D' : '') +
+        (hours || minutes || seconds ? 'T' : '') +
+        (hours ? hmsSign + hours + 'H' : '') +
+        (minutes ? hmsSign + minutes + 'M' : '') +
+        (seconds ? hmsSign + s + 'S' : '')
+    );
 }

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

@@ -4,50 +4,75 @@ var proto = Duration.prototype;
 
 import { abs } from './abs';
 import { add, subtract } from './add-subtract';
-import { as, asMilliseconds, asSeconds, asMinutes, asHours, asDays, asWeeks, asMonths, asQuarters, asYears, valueOf } from './as';
+import {
+    as,
+    asMilliseconds,
+    asSeconds,
+    asMinutes,
+    asHours,
+    asDays,
+    asWeeks,
+    asMonths,
+    asQuarters,
+    asYears,
+    valueOf,
+} from './as';
 import { bubble } from './bubble';
 import { clone } from './clone';
-import { get, milliseconds, seconds, minutes, hours, days, months, years, weeks } from './get';
+import {
+    get,
+    milliseconds,
+    seconds,
+    minutes,
+    hours,
+    days,
+    months,
+    years,
+    weeks,
+} from './get';
 import { humanize } from './humanize';
 import { toISOString } from './iso-string';
 import { lang, locale, localeData } from '../moment/locale';
 import { isValid } from './valid';
 
-proto.isValid        = isValid;
-proto.abs            = abs;
-proto.add            = add;
-proto.subtract       = subtract;
-proto.as             = as;
+proto.isValid = isValid;
+proto.abs = abs;
+proto.add = add;
+proto.subtract = subtract;
+proto.as = as;
 proto.asMilliseconds = asMilliseconds;
-proto.asSeconds      = asSeconds;
-proto.asMinutes      = asMinutes;
-proto.asHours        = asHours;
-proto.asDays         = asDays;
-proto.asWeeks        = asWeeks;
-proto.asMonths       = asMonths;
-proto.asQuarters     = asQuarters;
-proto.asYears        = asYears;
-proto.valueOf        = valueOf;
-proto._bubble        = bubble;
-proto.clone          = clone;
-proto.get            = get;
-proto.milliseconds   = milliseconds;
-proto.seconds        = seconds;
-proto.minutes        = minutes;
-proto.hours          = hours;
-proto.days           = days;
-proto.weeks          = weeks;
-proto.months         = months;
-proto.years          = years;
-proto.humanize       = humanize;
-proto.toISOString    = toISOString;
-proto.toString       = toISOString;
-proto.toJSON         = toISOString;
-proto.locale         = locale;
-proto.localeData     = localeData;
+proto.asSeconds = asSeconds;
+proto.asMinutes = asMinutes;
+proto.asHours = asHours;
+proto.asDays = asDays;
+proto.asWeeks = asWeeks;
+proto.asMonths = asMonths;
+proto.asQuarters = asQuarters;
+proto.asYears = asYears;
+proto.valueOf = valueOf;
+proto._bubble = bubble;
+proto.clone = clone;
+proto.get = get;
+proto.milliseconds = milliseconds;
+proto.seconds = seconds;
+proto.minutes = minutes;
+proto.hours = hours;
+proto.days = days;
+proto.weeks = weeks;
+proto.months = months;
+proto.years = years;
+proto.humanize = humanize;
+proto.toISOString = toISOString;
+proto.toString = toISOString;
+proto.toJSON = toISOString;
+proto.locale = locale;
+proto.localeData = localeData;
 
 // Deprecations
 import { deprecate } from '../utils/deprecate';
 
-proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString);
+proto.toIsoString = deprecate(
+    'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
+    toISOString
+);
 proto.lang = lang;

package/node_modules/moment/src/lib/duration/valid.js

@@ -1,19 +1,37 @@
+import hasOwnProp from '../utils/has-own-prop';
 import toInt from '../utils/to-int';
 import indexOf from '../utils/index-of';
-import {Duration} from './constructor';
-import {createDuration} from './create';
+import { createDuration } from './create';
 
-var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
+var ordering = [
+    'year',
+    'quarter',
+    'month',
+    'week',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'millisecond',
+];
 
 export default function isDurationValid(m) {
-    for (var key in m) {
-        if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
+    var key,
+        unitHasDecimal = false,
+        i;
+    for (key in m) {
+        if (
+            hasOwnProp(m, key) &&
+            !(
+                indexOf.call(ordering, key) !== -1 &&
+                (m[key] == null || !isNaN(m[key]))
+            )
+        ) {
             return false;
         }
     }
 
-    var unitHasDecimal = false;
-    for (var i = 0; i < ordering.length; ++i) {
+    for (i = 0; i < ordering.length; ++i) {
         if (m[ordering[i]]) {
             if (unitHasDecimal) {
                 return false; // only allow non-integers for smallest unit