card-mod-date 0.15.4 → 0.15.6

data/vendor/moment/src/lib/moment/start-end-of.js

@@ -0,0 +1,164 @@
+import { normalizeUnits } from '../units/aliases';
+import { hooks } from '../utils/hooks';
+
+var MS_PER_SECOND = 1000,
+    MS_PER_MINUTE = 60 * MS_PER_SECOND,
+    MS_PER_HOUR = 60 * MS_PER_MINUTE,
+    MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
+
+// actual modulo - handles negative numbers (for dates before 1970):
+function mod(dividend, divisor) {
+    return ((dividend % divisor) + divisor) % divisor;
+}
+
+function localStartOfDate(y, m, d) {
+    // the date constructor remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        // preserve leap years using a full 400 year cycle, then reset
+        return new Date(y + 400, m, d) - MS_PER_400_YEARS;
+    } else {
+        return new Date(y, m, d).valueOf();
+    }
+}
+
+function utcStartOfDate(y, m, d) {
+    // Date.UTC remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        // preserve leap years using a full 400 year cycle, then reset
+        return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
+    } else {
+        return Date.UTC(y, m, d);
+    }
+}
+
+export function startOf(units) {
+    var time, startOfDate;
+    units = normalizeUnits(units);
+    if (units === undefined || units === 'millisecond' || !this.isValid()) {
+        return this;
+    }
+
+    startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+
+    switch (units) {
+        case 'year':
+            time = startOfDate(this.year(), 0, 1);
+            break;
+        case 'quarter':
+            time = startOfDate(
+                this.year(),
+                this.month() - (this.month() % 3),
+                1
+            );
+            break;
+        case 'month':
+            time = startOfDate(this.year(), this.month(), 1);
+            break;
+        case 'week':
+            time = startOfDate(
+                this.year(),
+                this.month(),
+                this.date() - this.weekday()
+            );
+            break;
+        case 'isoWeek':
+            time = startOfDate(
+                this.year(),
+                this.month(),
+                this.date() - (this.isoWeekday() - 1)
+            );
+            break;
+        case 'day':
+        case 'date':
+            time = startOfDate(this.year(), this.month(), this.date());
+            break;
+        case 'hour':
+            time = this._d.valueOf();
+            time -= mod(
+                time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
+                MS_PER_HOUR
+            );
+            break;
+        case 'minute':
+            time = this._d.valueOf();
+            time -= mod(time, MS_PER_MINUTE);
+            break;
+        case 'second':
+            time = this._d.valueOf();
+            time -= mod(time, MS_PER_SECOND);
+            break;
+    }
+
+    this._d.setTime(time);
+    hooks.updateOffset(this, true);
+    return this;
+}
+
+export function endOf(units) {
+    var time, startOfDate;
+    units = normalizeUnits(units);
+    if (units === undefined || units === 'millisecond' || !this.isValid()) {
+        return this;
+    }
+
+    startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+
+    switch (units) {
+        case 'year':
+            time = startOfDate(this.year() + 1, 0, 1) - 1;
+            break;
+        case 'quarter':
+            time =
+                startOfDate(
+                    this.year(),
+                    this.month() - (this.month() % 3) + 3,
+                    1
+                ) - 1;
+            break;
+        case 'month':
+            time = startOfDate(this.year(), this.month() + 1, 1) - 1;
+            break;
+        case 'week':
+            time =
+                startOfDate(
+                    this.year(),
+                    this.month(),
+                    this.date() - this.weekday() + 7
+                ) - 1;
+            break;
+        case 'isoWeek':
+            time =
+                startOfDate(
+                    this.year(),
+                    this.month(),
+                    this.date() - (this.isoWeekday() - 1) + 7
+                ) - 1;
+            break;
+        case 'day':
+        case 'date':
+            time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
+            break;
+        case 'hour':
+            time = this._d.valueOf();
+            time +=
+                MS_PER_HOUR -
+                mod(
+                    time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
+                    MS_PER_HOUR
+                ) -
+                1;
+            break;
+        case 'minute':
+            time = this._d.valueOf();
+            time += MS_PER_MINUTE - mod(time, MS_PER_MINUTE) - 1;
+            break;
+        case 'second':
+            time = this._d.valueOf();
+            time += MS_PER_SECOND - mod(time, MS_PER_SECOND) - 1;
+            break;
+    }
+
+    this._d.setTime(time);
+    hooks.updateOffset(this, true);
+    return this;
+}

data/vendor/moment/src/lib/moment/to-type.js

@@ -0,0 +1,42 @@
+export function valueOf() {
+    return this._d.valueOf() - (this._offset || 0) * 60000;
+}
+
+export function unix() {
+    return Math.floor(this.valueOf() / 1000);
+}
+
+export function toDate() {
+    return new Date(this.valueOf());
+}
+
+export function toArray() {
+    var m = this;
+    return [
+        m.year(),
+        m.month(),
+        m.date(),
+        m.hour(),
+        m.minute(),
+        m.second(),
+        m.millisecond(),
+    ];
+}
+
+export function toObject() {
+    var m = this;
+    return {
+        years: m.year(),
+        months: m.month(),
+        date: m.date(),
+        hours: m.hours(),
+        minutes: m.minutes(),
+        seconds: m.seconds(),
+        milliseconds: m.milliseconds(),
+    };
+}
+
+export function toJSON() {
+    // new Date(NaN).toJSON() === null
+    return this.isValid() ? this.toISOString() : null;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { isValid as _isValid } from '../create/valid';
+import extend from '../utils/extend';
+import getParsingFlags from '../create/parsing-flags';
+
+export function isValid() {
+    return _isValid(this);
+}
+
+export function parsingFlags() {
+    return extend({}, getParsingFlags(this));
+}
+
+export function invalidAt() {
+    return getParsingFlags(this).overflow;
+}

data/vendor/moment/src/lib/parse/regex.js

@@ -0,0 +1,82 @@
+var match1 = /\d/, //       0 - 9
+    match2 = /\d\d/, //      00 - 99
+    match3 = /\d{3}/, //     000 - 999
+    match4 = /\d{4}/, //    0000 - 9999
+    match6 = /[+-]?\d{6}/, // -999999 - 999999
+    match1to2 = /\d\d?/, //       0 - 99
+    match3to4 = /\d\d\d\d?/, //     999 - 9999
+    match5to6 = /\d\d\d\d\d\d?/, //   99999 - 999999
+    match1to3 = /\d{1,3}/, //       0 - 999
+    match1to4 = /\d{1,4}/, //       0 - 9999
+    match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
+    matchUnsigned = /\d+/, //       0 - inf
+    matchSigned = /[+-]?\d+/, //    -inf - inf
+    matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
+    matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
+    matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
+    // any word (or two) characters or numbers including two/three word month in arabic.
+    // includes scottish gaelic two word and hyphenated months
+    matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
+    regexes;
+
+export {
+    match1,
+    match2,
+    match3,
+    match4,
+    match6,
+    match1to2,
+    match3to4,
+    match5to6,
+    match1to3,
+    match1to4,
+    match1to6,
+    matchUnsigned,
+    matchSigned,
+    matchOffset,
+    matchShortOffset,
+    matchTimestamp,
+    matchWord,
+};
+
+import hasOwnProp from '../utils/has-own-prop';
+import isFunction from '../utils/is-function';
+
+regexes = {};
+
+export function addRegexToken(token, regex, strictRegex) {
+    regexes[token] = isFunction(regex)
+        ? regex
+        : function (isStrict, localeData) {
+              return isStrict && strictRegex ? strictRegex : regex;
+          };
+}
+
+export function getParseRegexForToken(token, config) {
+    if (!hasOwnProp(regexes, token)) {
+        return new RegExp(unescapeFormat(token));
+    }
+
+    return regexes[token](config._strict, config._locale);
+}
+
+// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+function unescapeFormat(s) {
+    return regexEscape(
+        s
+            .replace('\\', '')
+            .replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (
+                matched,
+                p1,
+                p2,
+                p3,
+                p4
+            ) {
+                return p1 || p2 || p3 || p4;
+            })
+    );
+}
+
+export function regexEscape(s) {
+    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}

data/vendor/moment/src/lib/parse/token.js

@@ -0,0 +1,34 @@
+import hasOwnProp from '../utils/has-own-prop';
+import isNumber from '../utils/is-number';
+import toInt from '../utils/to-int';
+
+var tokens = {};
+
+export function addParseToken(token, callback) {
+    var i,
+        func = callback;
+    if (typeof token === 'string') {
+        token = [token];
+    }
+    if (isNumber(callback)) {
+        func = function (input, array) {
+            array[callback] = toInt(input);
+        };
+    }
+    for (i = 0; i < token.length; i++) {
+        tokens[token[i]] = func;
+    }
+}
+
+export function addWeekParseToken(token, callback) {
+    addParseToken(token, function (input, array, config, token) {
+        config._w = config._w || {};
+        callback(input, config._w, config, token);
+    });
+}
+
+export function addTimeToArrayFromToken(token, input, config) {
+    if (input != null && hasOwnProp(tokens, token)) {
+        tokens[token](input, config._a, config, token);
+    }
+}

data/vendor/moment/src/lib/units/aliases.js

@@ -0,0 +1,31 @@
+import hasOwnProp from '../utils/has-own-prop';
+
+var aliases = {};
+
+export function addUnitAlias(unit, shorthand) {
+    var lowerCase = unit.toLowerCase();
+    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+}
+
+export function normalizeUnits(units) {
+    return typeof units === 'string'
+        ? aliases[units] || aliases[units.toLowerCase()]
+        : undefined;
+}
+
+export function normalizeObjectUnits(inputObject) {
+    var normalizedInput = {},
+        normalizedProp,
+        prop;
+
+    for (prop in inputObject) {
+        if (hasOwnProp(inputObject, prop)) {
+            normalizedProp = normalizeUnits(prop);
+            if (normalizedProp) {
+                normalizedInput[normalizedProp] = inputObject[prop];
+            }
+        }
+    }
+
+    return normalizedInput;
+}

data/vendor/moment/src/lib/units/constants.js

@@ -0,0 +1,9 @@
+export var YEAR = 0,
+    MONTH = 1,
+    DATE = 2,
+    HOUR = 3,
+    MINUTE = 4,
+    SECOND = 5,
+    MILLISECOND = 6,
+    WEEK = 7,
+    WEEKDAY = 8;

data/vendor/moment/src/lib/units/day-of-month.js

@@ -0,0 +1,39 @@
+import { makeGetSet } from '../moment/get-set';
+import { addFormatToken } from '../format/format';
+import { addUnitAlias } from './aliases';
+import { addUnitPriority } from './priorities';
+import { addRegexToken, match1to2, match2 } from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { DATE } from './constants';
+import toInt from '../utils/to-int';
+
+// FORMATTING
+
+addFormatToken('D', ['DD', 2], 'Do', 'date');
+
+// ALIASES
+
+addUnitAlias('date', 'D');
+
+// PRIORITY
+addUnitPriority('date', 9);
+
+// PARSING
+
+addRegexToken('D', match1to2);
+addRegexToken('DD', match1to2, match2);
+addRegexToken('Do', function (isStrict, locale) {
+    // TODO: Remove "ordinalParse" fallback in next major release.
+    return isStrict
+        ? locale._dayOfMonthOrdinalParse || locale._ordinalParse
+        : locale._dayOfMonthOrdinalParseLenient;
+});
+
+addParseToken(['D', 'DD'], DATE);
+addParseToken('Do', function (input, array) {
+    array[DATE] = toInt(input.match(match1to2)[0]);
+});
+
+// MOMENTS
+
+export var getSetDayOfMonth = makeGetSet('Date', true);