@wavemaker/variables 11.8.0-next.141676 → 11.8.0-next.141679

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

@@ -1,135 +0,0 @@
-import { configFromISO, configFromRFC2822 } from './from-string';
-import { configFromArray } from './from-array';
-import { getParseRegexForToken } from '../parse/regex';
-import { addTimeToArrayFromToken } from '../parse/token';
-import {
-    expandFormat,
-    formatTokenFunctions,
-    formattingTokens,
-} from '../format/format';
-import checkOverflow from './check-overflow';
-import { YEAR, HOUR } from '../units/constants';
-import { hooks } from '../utils/hooks';
-import getParsingFlags from './parsing-flags';
-
-// constant that refers to the ISO standard
-hooks.ISO_8601 = function () {};
-
-// constant that refers to the RFC 2822 form
-hooks.RFC_2822 = function () {};
-
-// date from string and format string
-export function configFromStringAndFormat(config) {
-    // TODO: Move this to another part of the creation flow to prevent circular deps
-    if (config._f === hooks.ISO_8601) {
-        configFromISO(config);
-        return;
-    }
-    if (config._f === hooks.RFC_2822) {
-        configFromRFC2822(config);
-        return;
-    }
-    config._a = [];
-    getParsingFlags(config).empty = true;
-
-    // This array is used to make a Date, either with `new Date` or `Date.UTC`
-    var string = '' + config._i,
-        i,
-        parsedInput,
-        tokens,
-        token,
-        skipped,
-        stringLength = string.length,
-        totalParsedInputLength = 0,
-        era,
-        tokenLen;
-
-    tokens =
-        expandFormat(config._f, config._locale).match(formattingTokens) || [];
-    tokenLen = tokens.length;
-    for (i = 0; i < tokenLen; i++) {
-        token = tokens[i];
-        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
-            );
-            totalParsedInputLength += parsedInput.length;
-        }
-        // don't parse if it's not a known token
-        if (formatTokenFunctions[token]) {
-            if (parsedInput) {
-                getParsingFlags(config).empty = false;
-            } else {
-                getParsingFlags(config).unusedTokens.push(token);
-            }
-            addTimeToArrayFromToken(token, parsedInput, config);
-        } else if (config._strict && !parsedInput) {
-            getParsingFlags(config).unusedTokens.push(token);
-        }
-    }
-
-    // add remaining unparsed input length to the string
-    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 &&
-        getParsingFlags(config).bigHour === true &&
-        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
-    );
-
-    // 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) {
-    var isPm;
-
-    if (meridiem == null) {
-        // nothing to do
-        return hour;
-    }
-    if (locale.meridiemHour != null) {
-        return locale.meridiemHour(hour, meridiem);
-    } else if (locale.isPM != null) {
-        // Fallback
-        isPm = locale.isPM(meridiem);
-        if (isPm && hour < 12) {
-            hour += 12;
-        }
-        if (!isPm && hour === 12) {
-            hour = 0;
-        }
-        return hour;
-    } else {
-        // this is not supposed to happen
-        return hour;
-    }
-}

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

@@ -1,258 +0,0 @@
-import { configFromStringAndFormat } from './from-string-and-format';
-import { createUTCDate } from './date-from-array';
-import { hooks } from '../utils/hooks';
-import { deprecate } from '../utils/deprecate';
-import getParsingFlags from './parsing-flags';
-import { defaultLocaleMonthsShort } from '../units/month';
-import { defaultLocaleWeekdaysShort } from '../units/day-of-week';
-
-// iso 8601 regex
-// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
-var extendedIsoRegex =
-        /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
-    basicIsoRegex =
-        /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
-    tzRegex = /Z|[+-]\d\d(?::?\d\d)?/,
-    isoDates = [
-        ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
-        ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
-        ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
-        ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
-        ['YYYY-DDD', /\d{4}-\d{3}/],
-        ['YYYY-MM', /\d{4}-\d\d/, false],
-        ['YYYYYYMMDD', /[+-]\d{10}/],
-        ['YYYYMMDD', /\d{8}/],
-        ['GGGG[W]WWE', /\d{4}W\d{3}/],
-        ['GGGG[W]WW', /\d{4}W\d{2}/, false],
-        ['YYYYDDD', /\d{7}/],
-        ['YYYYMM', /\d{6}/, false],
-        ['YYYY', /\d{4}/, false],
-    ],
-    // iso time formats and regexes
-    isoTimes = [
-        ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
-        ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
-        ['HH:mm:ss', /\d\d:\d\d:\d\d/],
-        ['HH:mm', /\d\d:\d\d/],
-        ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
-        ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
-        ['HHmmss', /\d\d\d\d\d\d/],
-        ['HHmm', /\d\d\d\d/],
-        ['HH', /\d\d/],
-    ],
-    aspNetJsonRegex = /^\/?Date\((-?\d+)/i,
-    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
-    rfc2822 =
-        /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,
-    obsOffsets = {
-        UT: 0,
-        GMT: 0,
-        EDT: -4 * 60,
-        EST: -5 * 60,
-        CDT: -5 * 60,
-        CST: -6 * 60,
-        MDT: -6 * 60,
-        MST: -7 * 60,
-        PDT: -7 * 60,
-        PST: -8 * 60,
-    };
-
-// date from iso format
-export function configFromISO(config) {
-    var i,
-        l,
-        string = config._i,
-        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
-        allowTime,
-        dateFormat,
-        timeFormat,
-        tzFormat,
-        isoDatesLen = isoDates.length,
-        isoTimesLen = isoTimes.length;
-
-    if (match) {
-        getParsingFlags(config).iso = true;
-        for (i = 0, l = isoDatesLen; i < l; i++) {
-            if (isoDates[i][1].exec(match[1])) {
-                dateFormat = isoDates[i][0];
-                allowTime = isoDates[i][2] !== false;
-                break;
-            }
-        }
-        if (dateFormat == null) {
-            config._isValid = false;
-            return;
-        }
-        if (match[3]) {
-            for (i = 0, l = isoTimesLen; i < l; i++) {
-                if (isoTimes[i][1].exec(match[3])) {
-                    // match[2] should be 'T' or space
-                    timeFormat = (match[2] || ' ') + isoTimes[i][0];
-                    break;
-                }
-            }
-            if (timeFormat == null) {
-                config._isValid = false;
-                return;
-            }
-        }
-        if (!allowTime && timeFormat != null) {
-            config._isValid = false;
-            return;
-        }
-        if (match[4]) {
-            if (tzRegex.exec(match[4])) {
-                tzFormat = 'Z';
-            } else {
-                config._isValid = false;
-                return;
-            }
-        }
-        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
-        configFromStringAndFormat(config);
-    } else {
-        config._isValid = false;
-    }
-}
-
-function extractFromRFC2822Strings(
-    yearStr,
-    monthStr,
-    dayStr,
-    hourStr,
-    minuteStr,
-    secondStr
-) {
-    var result = [
-        untruncateYear(yearStr),
-        defaultLocaleMonthsShort.indexOf(monthStr),
-        parseInt(dayStr, 10),
-        parseInt(hourStr, 10),
-        parseInt(minuteStr, 10),
-    ];
-
-    if (secondStr) {
-        result.push(parseInt(secondStr, 10));
-    }
-
-    return result;
-}
-
-function untruncateYear(yearStr) {
-    var year = parseInt(yearStr, 10);
-    if (year <= 49) {
-        return 2000 + year;
-    } else if (year <= 999) {
-        return 1900 + year;
-    }
-    return year;
-}
-
-function preprocessRFC2822(s) {
-    // Remove comments and folding whitespace and replace multiple-spaces with a single space
-    return s
-        .replace(/\([^()]*\)|[\n\t]/g, ' ')
-        .replace(/(\s\s+)/g, ' ')
-        .replace(/^\s\s*/, '')
-        .replace(/\s\s*$/, '');
-}
-
-function checkWeekday(weekdayStr, parsedInput, config) {
-    if (weekdayStr) {
-        // TODO: Replace the vanilla JS Date object with an independent day-of-week check.
-        var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
-            weekdayActual = new Date(
-                parsedInput[0],
-                parsedInput[1],
-                parsedInput[2]
-            ).getDay();
-        if (weekdayProvided !== weekdayActual) {
-            getParsingFlags(config).weekdayMismatch = true;
-            config._isValid = false;
-            return false;
-        }
-    }
-    return true;
-}
-
-function calculateOffset(obsOffset, militaryOffset, numOffset) {
-    if (obsOffset) {
-        return obsOffsets[obsOffset];
-    } else if (militaryOffset) {
-        // the only allowed military tz is Z
-        return 0;
-    } else {
-        var hm = parseInt(numOffset, 10),
-            m = hm % 100,
-            h = (hm - m) / 100;
-        return h * 60 + m;
-    }
-}
-
-// date and time from ref 2822 format
-export function configFromRFC2822(config) {
-    var match = rfc2822.exec(preprocessRFC2822(config._i)),
-        parsedArray;
-    if (match) {
-        parsedArray = extractFromRFC2822Strings(
-            match[4],
-            match[3],
-            match[2],
-            match[5],
-            match[6],
-            match[7]
-        );
-        if (!checkWeekday(match[1], parsedArray, config)) {
-            return;
-        }
-
-        config._a = parsedArray;
-        config._tzm = calculateOffset(match[8], match[9], match[10]);
-
-        config._d = createUTCDate.apply(null, config._a);
-        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
-
-        getParsingFlags(config).rfc2822 = true;
-    } else {
-        config._isValid = false;
-    }
-}
-
-// date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict
-export function configFromString(config) {
-    var matched = aspNetJsonRegex.exec(config._i);
-    if (matched !== null) {
-        config._d = new Date(+matched[1]);
-        return;
-    }
-
-    configFromISO(config);
-    if (config._isValid === false) {
-        delete config._isValid;
-    } else {
-        return;
-    }
-
-    configFromRFC2822(config);
-    if (config._isValid === false) {
-        delete config._isValid;
-    } else {
-        return;
-    }
-
-    if (config._strict) {
-        config._isValid = false;
-    } else {
-        // Final attempt, use Input Fallback
-        hooks.createFromInputFallback(config);
-    }
-}
-
-hooks.createFromInputFallback = deprecate(
-    'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
-        'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
-        'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.',
-    function (config) {
-        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
-    }
-);

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

@@ -1,5 +0,0 @@
-import { createLocalOrUTC } from './from-anything';
-
-export function createLocal(input, format, locale, strict) {
-    return createLocalOrUTC(input, format, locale, strict, false);
-}

package/node_modules/moment/src/lib/create/parsing-flags.js

@@ -1,28 +0,0 @@
-function defaultParsingFlags() {
-    // We need to deep clone this object.
-    return {
-        empty: false,
-        unusedTokens: [],
-        unusedInput: [],
-        overflow: -2,
-        charsLeftOver: 0,
-        nullInput: false,
-        invalidEra: null,
-        invalidMonth: null,
-        invalidFormat: false,
-        userInvalidated: false,
-        iso: false,
-        parsedDateParts: [],
-        era: null,
-        meridiem: null,
-        rfc2822: false,
-        weekdayMismatch: false,
-    };
-}
-
-export default function getParsingFlags(m) {
-    if (m._pf == null) {
-        m._pf = defaultParsingFlags();
-    }
-    return m._pf;
-}

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

@@ -1,5 +0,0 @@
-import { createLocalOrUTC } from './from-anything';
-
-export function createUTC(input, format, locale, strict) {
-    return createLocalOrUTC(input, format, locale, strict, true).utc();
-}

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

@@ -1,51 +0,0 @@
-import extend from '../utils/extend';
-import { createUTC } from './utc';
-import getParsingFlags from '../create/parsing-flags';
-import some from '../utils/some';
-
-export function isValid(m) {
-    var flags = null,
-        parsedParts = false,
-        isNowValid = m._d && !isNaN(m._d.getTime());
-    if (isNowValid) {
-        flags = getParsingFlags(m);
-        parsedParts = some.call(flags.parsedDateParts, function (i) {
-            return i != null;
-        });
-        isNowValid =
-            flags.overflow < 0 &&
-            !flags.empty &&
-            !flags.invalidEra &&
-            !flags.invalidMonth &&
-            !flags.invalidWeekday &&
-            !flags.weekdayMismatch &&
-            !flags.nullInput &&
-            !flags.invalidFormat &&
-            !flags.userInvalidated &&
-            (!flags.meridiem || (flags.meridiem && parsedParts));
-        if (m._strict) {
-            isNowValid =
-                isNowValid &&
-                flags.charsLeftOver === 0 &&
-                flags.unusedTokens.length === 0 &&
-                flags.bigHour === undefined;
-        }
-    }
-    if (Object.isFrozen == null || !Object.isFrozen(m)) {
-        m._isValid = isNowValid;
-    } else {
-        return isNowValid;
-    }
-    return m._isValid;
-}
-
-export function createInvalid(flags) {
-    var m = createUTC(NaN);
-    if (flags != null) {
-        extend(getParsingFlags(m), flags);
-    } else {
-        getParsingFlags(m).userInvalidated = true;
-    }
-
-    return m;
-}

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

@@ -1,18 +0,0 @@
-var mathAbs = Math.abs;
-
-export function abs() {
-    var data = this._data;
-
-    this._milliseconds = mathAbs(this._milliseconds);
-    this._days = mathAbs(this._days);
-    this._months = mathAbs(this._months);
-
-    data.milliseconds = mathAbs(data.milliseconds);
-    data.seconds = mathAbs(data.seconds);
-    data.minutes = mathAbs(data.minutes);
-    data.hours = mathAbs(data.hours);
-    data.months = mathAbs(data.months);
-    data.years = mathAbs(data.years);
-
-    return this;
-}

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

@@ -1,21 +0,0 @@
-import { createDuration } from './create';
-
-function addSubtract(duration, input, value, direction) {
-    var other = createDuration(input, value);
-
-    duration._milliseconds += direction * other._milliseconds;
-    duration._days += direction * other._days;
-    duration._months += direction * other._months;
-
-    return duration._bubble();
-}
-
-// supports only 2.0-style add(1, 's') or add(duration)
-export function add(input, value) {
-    return addSubtract(this, input, value, 1);
-}
-
-// supports only 2.0-style subtract(1, 's') or subtract(duration)
-export function subtract(input, value) {
-    return addSubtract(this, input, value, -1);
-}

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

@@ -1,76 +0,0 @@
-import { daysToMonths, monthsToDays } from './bubble';
-import { normalizeUnits } from '../units/aliases';
-
-export function as(units) {
-    if (!this.isValid()) {
-        return NaN;
-    }
-    var days,
-        months,
-        milliseconds = this._milliseconds;
-
-    units = normalizeUnits(units);
-
-    if (units === 'month' || units === 'quarter' || units === 'year') {
-        days = this._days + milliseconds / 864e5;
-        months = this._months + daysToMonths(days);
-        switch (units) {
-            case 'month':
-                return months;
-            case 'quarter':
-                return months / 3;
-            case 'year':
-                return months / 12;
-        }
-    } else {
-        // handle milliseconds separately because of floating point math errors (issue #1867)
-        days = this._days + Math.round(monthsToDays(this._months));
-        switch (units) {
-            case 'week':
-                return days / 7 + milliseconds / 6048e5;
-            case 'day':
-                return days + milliseconds / 864e5;
-            case 'hour':
-                return days * 24 + milliseconds / 36e5;
-            case 'minute':
-                return days * 1440 + milliseconds / 6e4;
-            case 'second':
-                return days * 86400 + milliseconds / 1000;
-            // Math.floor prevents floating point math errors here
-            case 'millisecond':
-                return Math.floor(days * 864e5) + milliseconds;
-            default:
-                throw new Error('Unknown unit ' + units);
-        }
-    }
-}
-
-function makeAs(alias) {
-    return function () {
-        return this.as(alias);
-    };
-}
-
-var asMilliseconds = makeAs('ms'),
-    asSeconds = makeAs('s'),
-    asMinutes = makeAs('m'),
-    asHours = makeAs('h'),
-    asDays = makeAs('d'),
-    asWeeks = makeAs('w'),
-    asMonths = makeAs('M'),
-    asQuarters = makeAs('Q'),
-    asYears = makeAs('y'),
-    valueOf = asMilliseconds;
-
-export {
-    asMilliseconds,
-    asSeconds,
-    asMinutes,
-    asHours,
-    asDays,
-    asWeeks,
-    asMonths,
-    asQuarters,
-    asYears,
-    valueOf,
-};

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

@@ -1,68 +0,0 @@
-import absFloor from '../utils/abs-floor';
-import absCeil from '../utils/abs-ceil';
-
-export function bubble() {
-    var milliseconds = this._milliseconds,
-        days = this._days,
-        months = this._months,
-        data = this._data,
-        seconds,
-        minutes,
-        hours,
-        years,
-        monthsFromDays;
-
-    // if we have a mix of positive and negative values, bubble down first
-    // check: https://github.com/moment/moment/issues/2166
-    if (
-        !(
-            (milliseconds >= 0 && days >= 0 && months >= 0) ||
-            (milliseconds <= 0 && days <= 0 && months <= 0)
-        )
-    ) {
-        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
-        days = 0;
-        months = 0;
-    }
-
-    // The following code bubbles up values, see the tests for
-    // examples of what that means.
-    data.milliseconds = milliseconds % 1000;
-
-    seconds = absFloor(milliseconds / 1000);
-    data.seconds = seconds % 60;
-
-    minutes = absFloor(seconds / 60);
-    data.minutes = minutes % 60;
-
-    hours = absFloor(minutes / 60);
-    data.hours = hours % 24;
-
-    days += absFloor(hours / 24);
-
-    // convert days to months
-    monthsFromDays = absFloor(daysToMonths(days));
-    months += monthsFromDays;
-    days -= absCeil(monthsToDays(monthsFromDays));
-
-    // 12 months -> 1 year
-    years = absFloor(months / 12);
-    months %= 12;
-
-    data.days = days;
-    data.months = months;
-    data.years = years;
-
-    return this;
-}
-
-export function daysToMonths(days) {
-    // 400 years have 146097 days (taking into account leap year rules)
-    // 400 years have 12 months === 4800
-    return (days * 4800) / 146097;
-}
-
-export function monthsToDays(months) {
-    // the reverse of daysToMonths
-    return (months * 146097) / 4800;
-}

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

@@ -1,5 +0,0 @@
-import { createDuration } from './create';
-
-export function clone() {
-    return createDuration(this);
-}