card-mod-date 0.15.4 → 0.15.6

data/vendor/moment/src/lib/locale/locales.js

@@ -0,0 +1,242 @@
+import isArray from '../utils/is-array';
+import isUndefined from '../utils/is-undefined';
+import { deprecateSimple } from '../utils/deprecate';
+import { mergeConfigs } from './set';
+import { Locale } from './constructor';
+import keys from '../utils/keys';
+
+import { baseConfig } from './base-config';
+
+// internal storage for locale config files
+var locales = {},
+    localeFamilies = {},
+    globalLocale;
+
+function commonPrefix(arr1, arr2) {
+    var i,
+        minl = Math.min(arr1.length, arr2.length);
+    for (i = 0; i < minl; i += 1) {
+        if (arr1[i] !== arr2[i]) {
+            return i;
+        }
+    }
+    return minl;
+}
+
+function normalizeLocale(key) {
+    return key ? key.toLowerCase().replace('_', '-') : key;
+}
+
+// pick the locale from the array
+// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
+// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
+function chooseLocale(names) {
+    var i = 0,
+        j,
+        next,
+        locale,
+        split;
+
+    while (i < names.length) {
+        split = normalizeLocale(names[i]).split('-');
+        j = split.length;
+        next = normalizeLocale(names[i + 1]);
+        next = next ? next.split('-') : null;
+        while (j > 0) {
+            locale = loadLocale(split.slice(0, j).join('-'));
+            if (locale) {
+                return locale;
+            }
+            if (
+                next &&
+                next.length >= j &&
+                commonPrefix(split, next) >= j - 1
+            ) {
+                //the next array item is better than a shallower substring of this one
+                break;
+            }
+            j--;
+        }
+        i++;
+    }
+    return globalLocale;
+}
+
+function loadLocale(name) {
+    var oldLocale = null,
+        aliasedRequire;
+    // TODO: Find a better way to register and load all the locales in Node
+    if (
+        locales[name] === undefined &&
+        typeof module !== 'undefined' &&
+        module &&
+        module.exports
+    ) {
+        try {
+            oldLocale = globalLocale._abbr;
+            aliasedRequire = require;
+            aliasedRequire('./locale/' + name);
+            getSetGlobalLocale(oldLocale);
+        } catch (e) {
+            // mark as not found to avoid repeating expensive file require call causing high CPU
+            // when trying to find en-US, en_US, en-us for every format call
+            locales[name] = null; // null means not found
+        }
+    }
+    return locales[name];
+}
+
+// This function will load locale and then set the global locale.  If
+// no arguments are passed in, it will simply return the current global
+// locale key.
+export function getSetGlobalLocale(key, values) {
+    var data;
+    if (key) {
+        if (isUndefined(values)) {
+            data = getLocale(key);
+        } else {
+            data = defineLocale(key, values);
+        }
+
+        if (data) {
+            // moment.duration._locale = moment._locale = data;
+            globalLocale = data;
+        } else {
+            if (typeof console !== 'undefined' && console.warn) {
+                //warn user if arguments are passed but the locale could not be set
+                console.warn(
+                    'Locale ' + key + ' not found. Did you forget to load it?'
+                );
+            }
+        }
+    }
+
+    return globalLocale._abbr;
+}
+
+export function defineLocale(name, config) {
+    if (config !== null) {
+        var locale,
+            parentConfig = baseConfig;
+        config.abbr = name;
+        if (locales[name] != null) {
+            deprecateSimple(
+                'defineLocaleOverride',
+                'use moment.updateLocale(localeName, config) to change ' +
+                    'an existing locale. moment.defineLocale(localeName, ' +
+                    'config) should only be used for creating a new locale ' +
+                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'
+            );
+            parentConfig = locales[name]._config;
+        } else if (config.parentLocale != null) {
+            if (locales[config.parentLocale] != null) {
+                parentConfig = locales[config.parentLocale]._config;
+            } else {
+                locale = loadLocale(config.parentLocale);
+                if (locale != null) {
+                    parentConfig = locale._config;
+                } else {
+                    if (!localeFamilies[config.parentLocale]) {
+                        localeFamilies[config.parentLocale] = [];
+                    }
+                    localeFamilies[config.parentLocale].push({
+                        name: name,
+                        config: config,
+                    });
+                    return null;
+                }
+            }
+        }
+        locales[name] = new Locale(mergeConfigs(parentConfig, config));
+
+        if (localeFamilies[name]) {
+            localeFamilies[name].forEach(function (x) {
+                defineLocale(x.name, x.config);
+            });
+        }
+
+        // backwards compat for now: also set the locale
+        // make sure we set the locale AFTER all child locales have been
+        // created, so we won't end up with the child locale set.
+        getSetGlobalLocale(name);
+
+        return locales[name];
+    } else {
+        // useful for testing
+        delete locales[name];
+        return null;
+    }
+}
+
+export function updateLocale(name, config) {
+    if (config != null) {
+        var locale,
+            tmpLocale,
+            parentConfig = baseConfig;
+
+        if (locales[name] != null && locales[name].parentLocale != null) {
+            // Update existing child locale in-place to avoid memory-leaks
+            locales[name].set(mergeConfigs(locales[name]._config, config));
+        } else {
+            // MERGE
+            tmpLocale = loadLocale(name);
+            if (tmpLocale != null) {
+                parentConfig = tmpLocale._config;
+            }
+            config = mergeConfigs(parentConfig, config);
+            if (tmpLocale == null) {
+                // updateLocale is called for creating a new locale
+                // Set abbr so it will have a name (getters return
+                // undefined otherwise).
+                config.abbr = name;
+            }
+            locale = new Locale(config);
+            locale.parentLocale = locales[name];
+            locales[name] = locale;
+        }
+
+        // backwards compat for now: also set the locale
+        getSetGlobalLocale(name);
+    } else {
+        // pass null for config to unupdate, useful for tests
+        if (locales[name] != null) {
+            if (locales[name].parentLocale != null) {
+                locales[name] = locales[name].parentLocale;
+                if (name === getSetGlobalLocale()) {
+                    getSetGlobalLocale(name);
+                }
+            } else if (locales[name] != null) {
+                delete locales[name];
+            }
+        }
+    }
+    return locales[name];
+}
+
+// returns locale data
+export function getLocale(key) {
+    var locale;
+
+    if (key && key._locale && key._locale._abbr) {
+        key = key._locale._abbr;
+    }
+
+    if (!key) {
+        return globalLocale;
+    }
+
+    if (!isArray(key)) {
+        //short-circuit everything else
+        locale = loadLocale(key);
+        if (locale) {
+            return locale;
+        }
+        key = [key];
+    }
+
+    return chooseLocale(key);
+}
+
+export function listLocales() {
+    return keys(locales);
+}

data/vendor/moment/src/lib/locale/ordinal.js

@@ -0,0 +1,8 @@
+var defaultOrdinal = '%d',
+    defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+
+export { defaultOrdinal, defaultDayOfMonthOrdinalParse };
+
+export function ordinal(number) {
+    return this._ordinal.replace('%d', number);
+}

data/vendor/moment/src/lib/locale/pre-post-format.js

@@ -0,0 +1,3 @@
+export function preParsePostFormat(string) {
+    return string;
+}

data/vendor/moment/src/lib/locale/prototype.js

@@ -0,0 +1,88 @@
+import { Locale } from './constructor';
+
+var proto = Locale.prototype;
+
+import { calendar } from './calendar';
+import { longDateFormat } from './formats';
+import { invalidDate } from './invalid';
+import { ordinal } from './ordinal';
+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;
+
+// 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 {
+    localeMonthsParse,
+    localeMonths,
+    localeMonthsShort,
+    monthsRegex,
+    monthsShortRegex,
+} from '../units/month';
+
+proto.months = localeMonths;
+proto.monthsShort = localeMonthsShort;
+proto.monthsParse = localeMonthsParse;
+proto.monthsRegex = monthsRegex;
+proto.monthsShortRegex = monthsShortRegex;
+
+// Week
+import {
+    localeWeek,
+    localeFirstDayOfYear,
+    localeFirstDayOfWeek,
+} from '../units/week';
+proto.week = localeWeek;
+proto.firstDayOfYear = localeFirstDayOfYear;
+proto.firstDayOfWeek = localeFirstDayOfWeek;
+
+// Day of Week
+import {
+    localeWeekdaysParse,
+    localeWeekdays,
+    localeWeekdaysMin,
+    localeWeekdaysShort,
+    weekdaysRegex,
+    weekdaysShortRegex,
+    weekdaysMinRegex,
+} from '../units/day-of-week';
+
+proto.weekdays = localeWeekdays;
+proto.weekdaysMin = localeWeekdaysMin;
+proto.weekdaysShort = localeWeekdaysShort;
+proto.weekdaysParse = localeWeekdaysParse;
+
+proto.weekdaysRegex = weekdaysRegex;
+proto.weekdaysShortRegex = weekdaysShortRegex;
+proto.weekdaysMinRegex = weekdaysMinRegex;
+
+// Hours
+import { localeIsPM, localeMeridiem } from '../units/hour';
+
+proto.isPM = localeIsPM;
+proto.meridiem = localeMeridiem;

data/vendor/moment/src/lib/locale/relative.js

@@ -0,0 +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',
+    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) {
+    var output = this._relativeTime[string];
+    return isFunction(output)
+        ? output(number, withoutSuffix, string, isFuture)
+        : output.replace(/%d/i, number);
+}
+
+export function pastFuture(diff, output) {
+    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+    return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+}

data/vendor/moment/src/lib/locale/set.js

@@ -0,0 +1,56 @@
+import isFunction from '../utils/is-function';
+import extend from '../utils/extend';
+import isObject from '../utils/is-object';
+import hasOwnProp from '../utils/has-own-prop';
+
+export function set(config) {
+    var prop, i;
+    for (i in config) {
+        if (hasOwnProp(config, i)) {
+            prop = config[i];
+            if (isFunction(prop)) {
+                this[i] = prop;
+            } else {
+                this['_' + i] = prop;
+            }
+        }
+    }
+    this._config = config;
+    // Lenient ordinal parsing accepts just a number in addition to
+    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
+    // TODO: Remove "ordinalParse" fallback in next major release.
+    this._dayOfMonthOrdinalParseLenient = new RegExp(
+        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
+            '|' +
+            /\d{1,2}/.source
+    );
+}
+
+export function mergeConfigs(parentConfig, childConfig) {
+    var res = extend({}, parentConfig),
+        prop;
+    for (prop in childConfig) {
+        if (hasOwnProp(childConfig, prop)) {
+            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
+                res[prop] = {};
+                extend(res[prop], parentConfig[prop]);
+                extend(res[prop], childConfig[prop]);
+            } else if (childConfig[prop] != null) {
+                res[prop] = childConfig[prop];
+            } else {
+                delete res[prop];
+            }
+        }
+    }
+    for (prop in parentConfig) {
+        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]);
+        }
+    }
+    return res;
+}

data/vendor/moment/src/lib/moment/add-subtract.js

@@ -0,0 +1,61 @@
+import { get, set } from './get-set';
+import { setMonth } from '../units/month';
+import { createDuration } from '../duration/create';
+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;
+        }
+
+        dur = createDuration(val, period);
+        addSubtract(this, dur, direction);
+        return this;
+    };
+}
+
+export function addSubtract(mom, duration, isAdding, updateOffset) {
+    var milliseconds = duration._milliseconds,
+        days = absRound(duration._days),
+        months = absRound(duration._months);
+
+    if (!mom.isValid()) {
+        // No op
+        return;
+    }
+
+    updateOffset = updateOffset == null ? true : updateOffset;
+
+    if (months) {
+        setMonth(mom, get(mom, 'Month') + months * isAdding);
+    }
+    if (days) {
+        set(mom, 'Date', get(mom, 'Date') + days * isAdding);
+    }
+    if (milliseconds) {
+        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
+    }
+    if (updateOffset) {
+        hooks.updateOffset(mom, days || months);
+    }
+}
+
+export var add = createAdder(1, 'add'),
+    subtract = createAdder(-1, 'subtract');

data/vendor/moment/src/lib/moment/calendar.js

@@ -0,0 +1,53 @@
+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';
+}
+
+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',
+        output =
+            formats &&
+            (isFunction(formats[format])
+                ? formats[format].call(this, now)
+                : formats[format]);
+
+    return this.format(
+        output || this.localeData().calendar(format, this, createLocal(now))
+    );
+}

data/vendor/moment/src/lib/moment/clone.js

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

data/vendor/moment/src/lib/moment/compare.js

@@ -0,0 +1,72 @@
+import { isMoment } from './constructor';
+import { normalizeUnits } from '../units/aliases';
+import { createLocal } from '../create/local';
+
+export function isAfter(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input);
+    if (!(this.isValid() && localInput.isValid())) {
+        return false;
+    }
+    units = normalizeUnits(units) || 'millisecond';
+    if (units === 'millisecond') {
+        return this.valueOf() > localInput.valueOf();
+    } else {
+        return localInput.valueOf() < this.clone().startOf(units).valueOf();
+    }
+}
+
+export function isBefore(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input);
+    if (!(this.isValid() && localInput.isValid())) {
+        return false;
+    }
+    units = normalizeUnits(units) || 'millisecond';
+    if (units === 'millisecond') {
+        return this.valueOf() < localInput.valueOf();
+    } else {
+        return this.clone().endOf(units).valueOf() < localInput.valueOf();
+    }
+}
+
+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))
+    );
+}
+
+export function isSame(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input),
+        inputMs;
+    if (!(this.isValid() && localInput.isValid())) {
+        return false;
+    }
+    units = normalizeUnits(units) || 'millisecond';
+    if (units === 'millisecond') {
+        return this.valueOf() === localInput.valueOf();
+    } else {
+        inputMs = localInput.valueOf();
+        return (
+            this.clone().startOf(units).valueOf() <= inputMs &&
+            inputMs <= this.clone().endOf(units).valueOf()
+        );
+    }
+}
+
+export function isSameOrAfter(input, units) {
+    return this.isSame(input, units) || this.isAfter(input, units);
+}
+
+export function isSameOrBefore(input, units) {
+    return this.isSame(input, units) || this.isBefore(input, units);
+}