@contrast/agent 3.8.5 → 3.9.2

package/node_modules/moment/package.json

@@ -1,8 +1,8 @@
 {
     "name": "moment",
-    "version": "2.24.0",
+    "version": "2.29.1",
     "description": "Parse, validate, manipulate, and display dates",
-    "homepage": "http://momentjs.com",
+    "homepage": "https://momentjs.com",
     "author": "Iskren Ivov Chernev <iskren.chernev@gmail.com> (https://github.com/ichernev)",
     "contributors": [
         "Tim Wood <washwithcare@gmail.com> (http://timwoodcreates.com/)",
@@ -23,8 +23,15 @@
         "ender"
     ],
     "main": "./moment.js",
-    "jsnext:main": "./src/moment.js",
+    "jsnext:main": "./dist/moment.js",
     "typings": "./moment.d.ts",
+    "typesVersions": {
+        ">=3.1": {
+            "*": [
+                "ts3.1-typings/*"
+            ]
+        }
+    },
     "engines": {
         "node": "*"
     },
@@ -38,20 +45,20 @@
     "license": "MIT",
     "devDependencies": {
         "benchmark": "latest",
-        "coveralls": "^3.0.2",
+        "coveralls": "latest",
+        "cross-env": "^6.0.3",
         "es6-promise": "latest",
-        "grunt": "~0.4",
+        "eslint": "~6",
+        "grunt": "latest",
         "grunt-benchmark": "latest",
         "grunt-cli": "latest",
         "grunt-contrib-clean": "latest",
         "grunt-contrib-concat": "latest",
         "grunt-contrib-copy": "latest",
-        "grunt-contrib-jshint": "latest",
         "grunt-contrib-uglify": "latest",
-        "grunt-contrib-watch": "^1.1.0",
+        "grunt-contrib-watch": "latest",
         "grunt-env": "latest",
         "grunt-exec": "latest",
-        "grunt-jscs": "latest",
         "grunt-karma": "latest",
         "grunt-nuget": "latest",
         "grunt-string-replace": "latest",
@@ -59,14 +66,16 @@
         "karma-chrome-launcher": "latest",
         "karma-firefox-launcher": "latest",
         "karma-qunit": "latest",
-        "karma-sauce-launcher": "latest",
-        "load-grunt-tasks": "~3.5.2",
-        "node-qunit": "^1.0.0",
-        "nyc": "~11.9.0",
-        "qunit": "^2.7.1",
-        "rollup": "~0.67.4",
-        "spacejam": "latest",
+        "karma-sauce-launcher": "4.1.4",
+        "load-grunt-tasks": "latest",
+        "lodash": ">=4.17.19",
+        "node-qunit": "latest",
+        "nyc": "latest",
+        "prettier": "latest",
+        "qunit": "^2.10.0",
+        "rollup": "2.17.1",
         "typescript": "^1.8.10",
+        "typescript3": "npm:typescript@^3.1.6",
         "uglify-js": "latest"
     },
     "ender": "./ender.js",
@@ -85,8 +94,12 @@
         }
     },
     "scripts": {
-        "typescript-test": "tsc --project typing-tests",
+        "ts3.1-typescript-test": "cross-env node_modules/typescript3/bin/tsc --project ts3.1-typing-tests",
+        "typescript-test": "cross-env node_modules/typescript/bin/tsc --project typing-tests",
         "test": "grunt test",
+        "eslint": "eslint Gruntfile.js tasks src",
+        "prettier-check": "prettier --check Gruntfile.js tasks src",
+        "prettier-fmt": "prettier --write Gruntfile.js tasks src",
         "coverage": "nyc npm test && nyc report",
         "coveralls": "nyc npm test && nyc report --reporter=text-lcov | coveralls"
     },
@@ -97,7 +110,7 @@
         ]
     }
 
-,"_resolved": "https://registry.npmjs.org/moment/-/moment-2.24.0.tgz"
-,"_integrity": "sha512-bV7f+6l2QigeBBZSM/6yTNq4P2fNpSWj/0e7jQcy87A8e7o2nAfP/34/2ky5Vw4B9S446EtIhodAzkFCcR4dQg=="
-,"_from": "moment@2.24.0"
+,"_resolved": "https://registry.npmjs.org/moment/-/moment-2.29.1.tgz"
+,"_integrity": "sha512-kHmoybcPV8Sqy59DwNDY3Jefr64lK/by/da0ViFcuA4DH0vQg5Q6Ze5VimxkfQNSC+Mls/Kx53s7TjP1RhFEDQ=="
+,"_from": "moment@2.29.1"
 }

package/node_modules/moment/src/lib/create/check-overflow.js

@@ -1,22 +1,46 @@
 import { daysInMonth } from '../units/month';
-import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND, WEEK, WEEKDAY } from '../units/constants';
+import {
+    YEAR,
+    MONTH,
+    DATE,
+    HOUR,
+    MINUTE,
+    SECOND,
+    MILLISECOND,
+    WEEK,
+    WEEKDAY,
+} from '../units/constants';
 import getParsingFlags from '../create/parsing-flags';
 
-export default function checkOverflow (m) {
-    var overflow;
-    var a = m._a;
+export default function checkOverflow(m) {
+    var overflow,
+        a = m._a;
 
     if (a && getParsingFlags(m).overflow === -2) {
         overflow =
-            a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
-            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
-            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
-            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
-            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
-            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
-            -1;
+            a[MONTH] < 0 || a[MONTH] > 11
+                ? MONTH
+                : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
+                ? DATE
+                : a[HOUR] < 0 ||
+                  a[HOUR] > 24 ||
+                  (a[HOUR] === 24 &&
+                      (a[MINUTE] !== 0 ||
+                          a[SECOND] !== 0 ||
+                          a[MILLISECOND] !== 0))
+                ? HOUR
+                : a[MINUTE] < 0 || a[MINUTE] > 59
+                ? MINUTE
+                : a[SECOND] < 0 || a[SECOND] > 59
+                ? SECOND
+                : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
+                ? MILLISECOND
+                : -1;
 
-        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+        if (
+            getParsingFlags(m)._overflowDayOfYear &&
+            (overflow < YEAR || overflow > DATE)
+        ) {
             overflow = DATE;
         }
         if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
@@ -31,4 +55,3 @@ export default function checkOverflow (m) {
 
     return m;
 }
-

package/node_modules/moment/src/lib/create/date-from-array.js

@@ -1,4 +1,4 @@
-export function createDate (y, m, d, h, M, s, ms) {
+export function createDate(y, m, d, h, M, s, ms) {
     // can't just apply() to create a date:
     // https://stackoverflow.com/q/181348
     var date;
@@ -16,11 +16,11 @@ export function createDate (y, m, d, h, M, s, ms) {
     return date;
 }
 
-export function createUTCDate (y) {
-    var date;
+export function createUTCDate(y) {
+    var date, args;
     // the Date.UTC function remaps years 0-99 to 1900-1999
     if (y < 100 && y >= 0) {
-        var args = Array.prototype.slice.call(arguments);
+        args = Array.prototype.slice.call(arguments);
         // preserve leap years using a full 400 year cycle, then reset
         args[0] = y + 400;
         date = new Date(Date.UTC.apply(null, args));

package/node_modules/moment/src/lib/create/from-anything.js

@@ -12,13 +12,13 @@ import { hooks } from '../utils/hooks';
 import checkOverflow from './check-overflow';
 import { isValid } from './valid';
 
-import { configFromStringAndArray }  from './from-string-and-array';
+import { configFromStringAndArray } from './from-string-and-array';
 import { configFromStringAndFormat } from './from-string-and-format';
-import { configFromString }          from './from-string';
-import { configFromArray }           from './from-array';
-import { configFromObject }          from './from-object';
+import { configFromString } from './from-string';
+import { configFromArray } from './from-array';
+import { configFromObject } from './from-object';
 
-function createFromConfig (config) {
+function createFromConfig(config) {
     var res = new Moment(checkOverflow(prepareConfig(config)));
     if (res._nextDay) {
         // Adding is smart enough around DST
@@ -29,14 +29,14 @@ function createFromConfig (config) {
     return res;
 }
 
-export function prepareConfig (config) {
+export function prepareConfig(config) {
     var input = config._i,
         format = config._f;
 
     config._locale = config._locale || getLocale(config._l);
 
     if (input === null || (format === undefined && input === '')) {
-        return createInvalid({nullInput: true});
+        return createInvalid({ nullInput: true });
     }
 
     if (typeof input === 'string') {
@@ -51,7 +51,7 @@ export function prepareConfig (config) {
         configFromStringAndArray(config);
     } else if (format) {
         configFromStringAndFormat(config);
-    }  else {
+    } else {
         configFromInput(config);
     }
 
@@ -85,16 +85,23 @@ function configFromInput(config) {
     }
 }
 
-export function createLocalOrUTC (input, format, locale, strict, isUTC) {
+export function createLocalOrUTC(input, format, locale, strict, isUTC) {
     var c = {};
 
+    if (format === true || format === false) {
+        strict = format;
+        format = undefined;
+    }
+
     if (locale === true || locale === false) {
         strict = locale;
         locale = undefined;
     }
 
-    if ((isObject(input) && isObjectEmpty(input)) ||
-            (isArray(input) && input.length === 0)) {
+    if (
+        (isObject(input) && isObjectEmpty(input)) ||
+        (isArray(input) && input.length === 0)
+    ) {
         input = undefined;
     }
     // object construction must be done this way.

package/node_modules/moment/src/lib/create/from-array.js

@@ -1,8 +1,20 @@
 import { hooks } from '../utils/hooks';
 import { createDate, createUTCDate } from './date-from-array';
 import { daysInYear } from '../units/year';
-import { weekOfYear, weeksInYear, dayOfYearFromWeeks } from '../units/week-calendar-utils';
-import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from '../units/constants';
+import {
+    weekOfYear,
+    weeksInYear,
+    dayOfYearFromWeeks,
+} from '../units/week-calendar-utils';
+import {
+    YEAR,
+    MONTH,
+    DATE,
+    HOUR,
+    MINUTE,
+    SECOND,
+    MILLISECOND,
+} from '../units/constants';
 import { createLocal } from './local';
 import defaults from '../utils/defaults';
 import getParsingFlags from './parsing-flags';
@@ -11,7 +23,11 @@ function currentDateArray(config) {
     // hooks is actually the exported moment object
     var nowValue = new Date(hooks.now());
     if (config._useUTC) {
-        return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
+        return [
+            nowValue.getUTCFullYear(),
+            nowValue.getUTCMonth(),
+            nowValue.getUTCDate(),
+        ];
     }
     return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
 }
@@ -20,8 +36,13 @@ function currentDateArray(config) {
 // the array should mirror the parameters below
 // note: all values past the year are optional and will default to the lowest possible value.
 // [year, month, day , hour, minute, second, millisecond]
-export function configFromArray (config) {
-    var i, date, input = [], currentDate, expectedWeekday, yearToUse;
+export function configFromArray(config) {
+    var i,
+        date,
+        input = [],
+        currentDate,
+        expectedWeekday,
+        yearToUse;
 
     if (config._d) {
         return;
@@ -38,7 +59,10 @@ export function configFromArray (config) {
     if (config._dayOfYear != null) {
         yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
 
-        if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
+        if (
+            config._dayOfYear > daysInYear(yearToUse) ||
+            config._dayOfYear === 0
+        ) {
             getParsingFlags(config)._overflowDayOfYear = true;
         }
 
@@ -58,20 +82,28 @@ export function configFromArray (config) {
 
     // Zero out whatever was not defaulted, including time
     for (; i < 7; i++) {
-        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
+        config._a[i] = input[i] =
+            config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i];
     }
 
     // Check for 24:00:00.000
-    if (config._a[HOUR] === 24 &&
-            config._a[MINUTE] === 0 &&
-            config._a[SECOND] === 0 &&
-            config._a[MILLISECOND] === 0) {
+    if (
+        config._a[HOUR] === 24 &&
+        config._a[MINUTE] === 0 &&
+        config._a[SECOND] === 0 &&
+        config._a[MILLISECOND] === 0
+    ) {
         config._nextDay = true;
         config._a[HOUR] = 0;
     }
 
-    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
-    expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
+    config._d = (config._useUTC ? createUTCDate : createDate).apply(
+        null,
+        input
+    );
+    expectedWeekday = config._useUTC
+        ? config._d.getUTCDay()
+        : config._d.getDay();
 
     // Apply timezone offset from input. The actual utcOffset can be changed
     // with parseZone.
@@ -84,13 +116,17 @@ export function configFromArray (config) {
     }
 
     // check for mismatching day of week
-    if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
+    if (
+        config._w &&
+        typeof config._w.d !== 'undefined' &&
+        config._w.d !== expectedWeekday
+    ) {
         getParsingFlags(config).weekdayMismatch = true;
     }
 }
 
 function dayOfYearFromWeekInfo(config) {
-    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
+    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
 
     w = config._w;
     if (w.GG != null || w.W != null || w.E != null) {
@@ -101,7 +137,11 @@ function dayOfYearFromWeekInfo(config) {
         // how we interpret now (local, utc, fixed offset). So create
         // a now version of current config (take local/utc/offset flags, and
         // create now).
-        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
+        weekYear = defaults(
+            w.GG,
+            config._a[YEAR],
+            weekOfYear(createLocal(), 1, 4).year
+        );
         week = defaults(w.W, 1);
         weekday = defaults(w.E, 1);
         if (weekday < 1 || weekday > 7) {
@@ -111,7 +151,7 @@ function dayOfYearFromWeekInfo(config) {
         dow = config._locale._week.dow;
         doy = config._locale._week.doy;
 
-        var curWeek = weekOfYear(createLocal(), dow, doy);
+        curWeek = weekOfYear(createLocal(), dow, doy);
 
         weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
 

package/node_modules/moment/src/lib/create/from-object.js

@@ -7,10 +7,14 @@ export function configFromObject(config) {
         return;
     }
 
-    var i = normalizeObjectUnits(config._i);
-    config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
-        return obj && parseInt(obj, 10);
-    });
+    var i = normalizeObjectUnits(config._i),
+        dayOrDate = i.day === undefined ? i.date : i.day;
+    config._a = map(
+        [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
+        function (obj) {
+            return obj && parseInt(obj, 10);
+        }
+    );
 
     configFromArray(config);
 }

package/node_modules/moment/src/lib/create/from-string-and-array.js

@@ -8,10 +8,11 @@ import extend from '../utils/extend';
 export function configFromStringAndArray(config) {
     var tempConfig,
         bestMoment,
-
         scoreToBeat,
         i,
-        currentScore;
+        currentScore,
+        validFormatFound,
+        bestFormatIsValid = false;
 
     if (config._f.length === 0) {
         getParsingFlags(config).invalidFormat = true;
@@ -21,6 +22,7 @@ export function configFromStringAndArray(config) {
 
     for (i = 0; i < config._f.length; i++) {
         currentScore = 0;
+        validFormatFound = false;
         tempConfig = copyConfig({}, config);
         if (config._useUTC != null) {
             tempConfig._useUTC = config._useUTC;
@@ -28,8 +30,8 @@ export function configFromStringAndArray(config) {
         tempConfig._f = config._f[i];
         configFromStringAndFormat(tempConfig);
 
-        if (!isValid(tempConfig)) {
-            continue;
+        if (isValid(tempConfig)) {
+            validFormatFound = true;
         }
 
         // if there is any input that was not parsed add a penalty for that format
@@ -40,9 +42,23 @@ export function configFromStringAndArray(config) {
 
         getParsingFlags(tempConfig).score = currentScore;
 
-        if (scoreToBeat == null || currentScore < scoreToBeat) {
-            scoreToBeat = currentScore;
-            bestMoment = tempConfig;
+        if (!bestFormatIsValid) {
+            if (
+                scoreToBeat == null ||
+                currentScore < scoreToBeat ||
+                validFormatFound
+            ) {
+                scoreToBeat = currentScore;
+                bestMoment = tempConfig;
+                if (validFormatFound) {
+                    bestFormatIsValid = true;
+                }
+            }
+        } else {
+            if (currentScore < scoreToBeat) {
+                scoreToBeat = currentScore;
+                bestMoment = tempConfig;
+            }
         }
     }
 

package/node_modules/moment/src/lib/create/from-string-and-format.js

@@ -1,10 +1,14 @@
 import { configFromISO, configFromRFC2822 } from './from-string';
 import { configFromArray } from './from-array';
-import { getParseRegexForToken }   from '../parse/regex';
+import { getParseRegexForToken } from '../parse/regex';
 import { addTimeToArrayFromToken } from '../parse/token';
-import { expandFormat, formatTokenFunctions, formattingTokens } from '../format/format';
+import {
+    expandFormat,
+    formatTokenFunctions,
+    formattingTokens,
+} from '../format/format';
 import checkOverflow from './check-overflow';
-import { HOUR } from '../units/constants';
+import { YEAR, HOUR } from '../units/constants';
 import { hooks } from '../utils/hooks';
 import getParsingFlags from './parsing-flags';
 
@@ -30,64 +34,81 @@ export function configFromStringAndFormat(config) {
 
     // This array is used to make a Date, either with `new Date` or `Date.UTC`
     var string = '' + config._i,
-        i, parsedInput, tokens, token, skipped,
+        i,
+        parsedInput,
+        tokens,
+        token,
+        skipped,
         stringLength = string.length,
-        totalParsedInputLength = 0;
+        totalParsedInputLength = 0,
+        era;
 
-    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
+    tokens =
+        expandFormat(config._f, config._locale).match(formattingTokens) || [];
 
     for (i = 0; i < tokens.length; i++) {
         token = tokens[i];
-        parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
-        // console.log('token', token, 'parsedInput', parsedInput,
-        //         'regex', getParseRegexForToken(token, config));
+        parsedInput = (string.match(getParseRegexForToken(token, config)) ||
+            [])[0];
         if (parsedInput) {
             skipped = string.substr(0, string.indexOf(parsedInput));
             if (skipped.length > 0) {
                 getParsingFlags(config).unusedInput.push(skipped);
             }
-            string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
+            string = string.slice(
+                string.indexOf(parsedInput) + parsedInput.length
+            );
             totalParsedInputLength += parsedInput.length;
         }
         // don't parse if it's not a known token
         if (formatTokenFunctions[token]) {
             if (parsedInput) {
                 getParsingFlags(config).empty = false;
-            }
-            else {
+            } else {
                 getParsingFlags(config).unusedTokens.push(token);
             }
             addTimeToArrayFromToken(token, parsedInput, config);
-        }
-        else if (config._strict && !parsedInput) {
+        } else if (config._strict && !parsedInput) {
             getParsingFlags(config).unusedTokens.push(token);
         }
     }
 
     // add remaining unparsed input length to the string
-    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
+    getParsingFlags(config).charsLeftOver =
+        stringLength - totalParsedInputLength;
     if (string.length > 0) {
         getParsingFlags(config).unusedInput.push(string);
     }
 
     // clear _12h flag if hour is <= 12
-    if (config._a[HOUR] <= 12 &&
+    if (
+        config._a[HOUR] <= 12 &&
         getParsingFlags(config).bigHour === true &&
-        config._a[HOUR] > 0) {
+        config._a[HOUR] > 0
+    ) {
         getParsingFlags(config).bigHour = undefined;
     }
 
     getParsingFlags(config).parsedDateParts = config._a.slice(0);
     getParsingFlags(config).meridiem = config._meridiem;
     // handle meridiem
-    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
+    config._a[HOUR] = meridiemFixWrap(
+        config._locale,
+        config._a[HOUR],
+        config._meridiem
+    );
+
+    // handle era
+    era = getParsingFlags(config).era;
+    if (era !== null) {
+        config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
+    }
 
     configFromArray(config);
     checkOverflow(config);
 }
 
-
-function meridiemFixWrap (locale, hour, meridiem) {
+function meridiemFixWrap(locale, hour, meridiem) {
     var isPm;
 
     if (meridiem == null) {