cbs-block 1.0.8 → 1.0.10

package/WeatherAPI/node_modules/moment/src/lib/units/month.js

@@ -0,0 +1,340 @@
+import { get } from '../moment/get-set';
+import hasOwnProp from '../utils/has-own-prop';
+import { addFormatToken } from '../format/format';
+import {
+    addRegexToken,
+    match1to2,
+    match2,
+    matchWord,
+    regexEscape,
+    match1to2NoLeadingZero,
+} from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { hooks } from '../utils/hooks';
+import { MONTH } from './constants';
+import toInt from '../utils/to-int';
+import isArray from '../utils/is-array';
+import isNumber from '../utils/is-number';
+import mod from '../utils/mod';
+import indexOf from '../utils/index-of';
+import { createUTC } from '../create/utc';
+import getParsingFlags from '../create/parsing-flags';
+import { isLeapYear } from '../utils/is-leap-year';
+
+export function daysInMonth(year, month) {
+    if (isNaN(year) || isNaN(month)) {
+        return NaN;
+    }
+    var modMonth = mod(month, 12);
+    year += (month - modMonth) / 12;
+    return modMonth === 1
+        ? isLeapYear(year)
+            ? 29
+            : 28
+        : 31 - ((modMonth % 7) % 2);
+}
+
+// FORMATTING
+
+addFormatToken('M', ['MM', 2], 'Mo', function () {
+    return this.month() + 1;
+});
+
+addFormatToken('MMM', 0, 0, function (format) {
+    return this.localeData().monthsShort(this, format);
+});
+
+addFormatToken('MMMM', 0, 0, function (format) {
+    return this.localeData().months(this, format);
+});
+
+// PARSING
+
+addRegexToken('M', match1to2, match1to2NoLeadingZero);
+addRegexToken('MM', match1to2, match2);
+addRegexToken('MMM', function (isStrict, locale) {
+    return locale.monthsShortRegex(isStrict);
+});
+addRegexToken('MMMM', function (isStrict, locale) {
+    return locale.monthsRegex(isStrict);
+});
+
+addParseToken(['M', 'MM'], function (input, array) {
+    array[MONTH] = toInt(input) - 1;
+});
+
+addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
+    var month = config._locale.monthsParse(input, token, config._strict);
+    // if we didn't find a month name, mark the date as invalid.
+    if (month != null) {
+        array[MONTH] = month;
+    } else {
+        getParsingFlags(config).invalidMonth = input;
+    }
+});
+
+// LOCALES
+
+var defaultLocaleMonths =
+        'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+            '_'
+        ),
+    defaultLocaleMonthsShort =
+        'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+    MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
+    defaultMonthsShortRegex = matchWord,
+    defaultMonthsRegex = matchWord;
+
+export { defaultLocaleMonths, defaultLocaleMonthsShort };
+
+export function localeMonths(m, format) {
+    if (!m) {
+        return isArray(this._months)
+            ? this._months
+            : this._months['standalone'];
+    }
+    return isArray(this._months)
+        ? this._months[m.month()]
+        : this._months[
+              (this._months.isFormat || MONTHS_IN_FORMAT).test(format)
+                  ? 'format'
+                  : 'standalone'
+          ][m.month()];
+}
+
+export function localeMonthsShort(m, format) {
+    if (!m) {
+        return isArray(this._monthsShort)
+            ? this._monthsShort
+            : this._monthsShort['standalone'];
+    }
+    return isArray(this._monthsShort)
+        ? this._monthsShort[m.month()]
+        : this._monthsShort[
+              MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'
+          ][m.month()];
+}
+
+function handleStrictParse(monthName, format, strict) {
+    var i,
+        ii,
+        mom,
+        llc = monthName.toLocaleLowerCase();
+    if (!this._monthsParse) {
+        // this is not used
+        this._monthsParse = [];
+        this._longMonthsParse = [];
+        this._shortMonthsParse = [];
+        for (i = 0; i < 12; ++i) {
+            mom = createUTC([2000, i]);
+            this._shortMonthsParse[i] = this.monthsShort(
+                mom,
+                ''
+            ).toLocaleLowerCase();
+            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
+        }
+    }
+
+    if (strict) {
+        if (format === 'MMM') {
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        } else {
+            ii = indexOf.call(this._longMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        }
+    } else {
+        if (format === 'MMM') {
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._longMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        } else {
+            ii = indexOf.call(this._longMonthsParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        }
+    }
+}
+
+export function localeMonthsParse(monthName, format, strict) {
+    var i, mom, regex;
+
+    if (this._monthsParseExact) {
+        return handleStrictParse.call(this, monthName, format, strict);
+    }
+
+    if (!this._monthsParse) {
+        this._monthsParse = [];
+        this._longMonthsParse = [];
+        this._shortMonthsParse = [];
+    }
+
+    // TODO: add sorting
+    // Sorting makes sure if one month (or abbr) is a prefix of another
+    // see sorting in computeMonthsParse
+    for (i = 0; i < 12; i++) {
+        // make the regex if we don't have it already
+        mom = createUTC([2000, i]);
+        if (strict && !this._longMonthsParse[i]) {
+            this._longMonthsParse[i] = new RegExp(
+                '^' + this.months(mom, '').replace('.', '') + '$',
+                'i'
+            );
+            this._shortMonthsParse[i] = new RegExp(
+                '^' + this.monthsShort(mom, '').replace('.', '') + '$',
+                'i'
+            );
+        }
+        if (!strict && !this._monthsParse[i]) {
+            regex =
+                '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
+            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
+        }
+        // test the regex
+        if (
+            strict &&
+            format === 'MMMM' &&
+            this._longMonthsParse[i].test(monthName)
+        ) {
+            return i;
+        } else if (
+            strict &&
+            format === 'MMM' &&
+            this._shortMonthsParse[i].test(monthName)
+        ) {
+            return i;
+        } else if (!strict && this._monthsParse[i].test(monthName)) {
+            return i;
+        }
+    }
+}
+
+// MOMENTS
+
+export function setMonth(mom, value) {
+    if (!mom.isValid()) {
+        // No op
+        return mom;
+    }
+
+    if (typeof value === 'string') {
+        if (/^\d+$/.test(value)) {
+            value = toInt(value);
+        } else {
+            value = mom.localeData().monthsParse(value);
+            // TODO: Another silent failure?
+            if (!isNumber(value)) {
+                return mom;
+            }
+        }
+    }
+
+    var month = value,
+        date = mom.date();
+
+    date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month));
+    void (mom._isUTC
+        ? mom._d.setUTCMonth(month, date)
+        : mom._d.setMonth(month, date));
+    return mom;
+}
+
+export function getSetMonth(value) {
+    if (value != null) {
+        setMonth(this, value);
+        hooks.updateOffset(this, true);
+        return this;
+    } else {
+        return get(this, 'Month');
+    }
+}
+
+export function getDaysInMonth() {
+    return daysInMonth(this.year(), this.month());
+}
+
+export function monthsShortRegex(isStrict) {
+    if (this._monthsParseExact) {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            computeMonthsParse.call(this);
+        }
+        if (isStrict) {
+            return this._monthsShortStrictRegex;
+        } else {
+            return this._monthsShortRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_monthsShortRegex')) {
+            this._monthsShortRegex = defaultMonthsShortRegex;
+        }
+        return this._monthsShortStrictRegex && isStrict
+            ? this._monthsShortStrictRegex
+            : this._monthsShortRegex;
+    }
+}
+
+export function monthsRegex(isStrict) {
+    if (this._monthsParseExact) {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            computeMonthsParse.call(this);
+        }
+        if (isStrict) {
+            return this._monthsStrictRegex;
+        } else {
+            return this._monthsRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            this._monthsRegex = defaultMonthsRegex;
+        }
+        return this._monthsStrictRegex && isStrict
+            ? this._monthsStrictRegex
+            : this._monthsRegex;
+    }
+}
+
+function computeMonthsParse() {
+    function cmpLenRev(a, b) {
+        return b.length - a.length;
+    }
+
+    var shortPieces = [],
+        longPieces = [],
+        mixedPieces = [],
+        i,
+        mom,
+        shortP,
+        longP;
+    for (i = 0; i < 12; i++) {
+        // make the regex if we don't have it already
+        mom = createUTC([2000, i]);
+        shortP = regexEscape(this.monthsShort(mom, ''));
+        longP = regexEscape(this.months(mom, ''));
+        shortPieces.push(shortP);
+        longPieces.push(longP);
+        mixedPieces.push(longP);
+        mixedPieces.push(shortP);
+    }
+    // Sorting makes sure if one month (or abbr) is a prefix of another it
+    // will match the longer piece.
+    shortPieces.sort(cmpLenRev);
+    longPieces.sort(cmpLenRev);
+    mixedPieces.sort(cmpLenRev);
+
+    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+    this._monthsShortRegex = this._monthsRegex;
+    this._monthsStrictRegex = new RegExp(
+        '^(' + longPieces.join('|') + ')',
+        'i'
+    );
+    this._monthsShortStrictRegex = new RegExp(
+        '^(' + shortPieces.join('|') + ')',
+        'i'
+    );
+}

package/WeatherAPI/node_modules/moment/src/lib/units/offset.js

@@ -0,0 +1,249 @@
+import zeroFill from '../utils/zero-fill';
+import { createDuration } from '../duration/create';
+import { addSubtract } from '../moment/add-subtract';
+import { isMoment, copyConfig } from '../moment/constructor';
+import { addFormatToken } from '../format/format';
+import { addRegexToken, matchOffset, matchShortOffset } from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { createLocal } from '../create/local';
+import { prepareConfig } from '../create/from-anything';
+import { createUTC } from '../create/utc';
+import isDate from '../utils/is-date';
+import toInt from '../utils/to-int';
+import isUndefined from '../utils/is-undefined';
+import compareArrays from '../utils/compare-arrays';
+import { hooks } from '../utils/hooks';
+
+// FORMATTING
+
+function offset(token, separator) {
+    addFormatToken(token, 0, 0, function () {
+        var offset = this.utcOffset(),
+            sign = '+';
+        if (offset < 0) {
+            offset = -offset;
+            sign = '-';
+        }
+        return (
+            sign +
+            zeroFill(~~(offset / 60), 2) +
+            separator +
+            zeroFill(~~offset % 60, 2)
+        );
+    });
+}
+
+offset('Z', ':');
+offset('ZZ', '');
+
+// PARSING
+
+addRegexToken('Z', matchShortOffset);
+addRegexToken('ZZ', matchShortOffset);
+addParseToken(['Z', 'ZZ'], function (input, array, config) {
+    config._useUTC = true;
+    config._tzm = offsetFromString(matchShortOffset, input);
+});
+
+// HELPERS
+
+// timezone chunker
+// '+10:00' > ['10',  '00']
+// '-1530'  > ['-15', '30']
+var chunkOffset = /([\+\-]|\d\d)/gi;
+
+function offsetFromString(matcher, string) {
+    var matches = (string || '').match(matcher),
+        chunk,
+        parts,
+        minutes;
+
+    if (matches === null) {
+        return null;
+    }
+
+    chunk = matches[matches.length - 1] || [];
+    parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
+    minutes = +(parts[1] * 60) + toInt(parts[2]);
+
+    return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;
+}
+
+// Return a moment from input, that is local/utc/zone equivalent to model.
+export function cloneWithOffset(input, model) {
+    var res, diff;
+    if (model._isUTC) {
+        res = model.clone();
+        diff =
+            (isMoment(input) || isDate(input)
+                ? input.valueOf()
+                : createLocal(input).valueOf()) - res.valueOf();
+        // Use low-level api, because this fn is low-level api.
+        res._d.setTime(res._d.valueOf() + diff);
+        hooks.updateOffset(res, false);
+        return res;
+    } else {
+        return createLocal(input).local();
+    }
+}
+
+function getDateOffset(m) {
+    // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+    // https://github.com/moment/moment/pull/1871
+    return -Math.round(m._d.getTimezoneOffset());
+}
+
+// HOOKS
+
+// This function will be called whenever a moment is mutated.
+// It is intended to keep the offset in sync with the timezone.
+hooks.updateOffset = function () {};
+
+// MOMENTS
+
+// keepLocalTime = true means only change the timezone, without
+// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
+// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
+// +0200, so we adjust the time as needed, to be valid.
+//
+// Keeping the time actually adds/subtracts (one hour)
+// from the actual represented time. That is why we call updateOffset
+// a second time. In case it wants us to change the offset again
+// _changeInProgress == true case, then we have to adjust, because
+// there is no such time in the given timezone.
+export function getSetOffset(input, keepLocalTime, keepMinutes) {
+    var offset = this._offset || 0,
+        localAdjust;
+    if (!this.isValid()) {
+        return input != null ? this : NaN;
+    }
+    if (input != null) {
+        if (typeof input === 'string') {
+            input = offsetFromString(matchShortOffset, input);
+            if (input === null) {
+                return this;
+            }
+        } else if (Math.abs(input) < 16 && !keepMinutes) {
+            input = input * 60;
+        }
+        if (!this._isUTC && keepLocalTime) {
+            localAdjust = getDateOffset(this);
+        }
+        this._offset = input;
+        this._isUTC = true;
+        if (localAdjust != null) {
+            this.add(localAdjust, 'm');
+        }
+        if (offset !== input) {
+            if (!keepLocalTime || this._changeInProgress) {
+                addSubtract(
+                    this,
+                    createDuration(input - offset, 'm'),
+                    1,
+                    false
+                );
+            } else if (!this._changeInProgress) {
+                this._changeInProgress = true;
+                hooks.updateOffset(this, true);
+                this._changeInProgress = null;
+            }
+        }
+        return this;
+    } else {
+        return this._isUTC ? offset : getDateOffset(this);
+    }
+}
+
+export function getSetZone(input, keepLocalTime) {
+    if (input != null) {
+        if (typeof input !== 'string') {
+            input = -input;
+        }
+
+        this.utcOffset(input, keepLocalTime);
+
+        return this;
+    } else {
+        return -this.utcOffset();
+    }
+}
+
+export function setOffsetToUTC(keepLocalTime) {
+    return this.utcOffset(0, keepLocalTime);
+}
+
+export function setOffsetToLocal(keepLocalTime) {
+    if (this._isUTC) {
+        this.utcOffset(0, keepLocalTime);
+        this._isUTC = false;
+
+        if (keepLocalTime) {
+            this.subtract(getDateOffset(this), 'm');
+        }
+    }
+    return this;
+}
+
+export function setOffsetToParsedOffset() {
+    if (this._tzm != null) {
+        this.utcOffset(this._tzm, false, true);
+    } else if (typeof this._i === 'string') {
+        var tZone = offsetFromString(matchOffset, this._i);
+        if (tZone != null) {
+            this.utcOffset(tZone);
+        } else {
+            this.utcOffset(0, true);
+        }
+    }
+    return this;
+}
+
+export function hasAlignedHourOffset(input) {
+    if (!this.isValid()) {
+        return false;
+    }
+    input = input ? createLocal(input).utcOffset() : 0;
+
+    return (this.utcOffset() - input) % 60 === 0;
+}
+
+export function isDaylightSavingTime() {
+    return (
+        this.utcOffset() > this.clone().month(0).utcOffset() ||
+        this.utcOffset() > this.clone().month(5).utcOffset()
+    );
+}
+
+export function isDaylightSavingTimeShifted() {
+    if (!isUndefined(this._isDSTShifted)) {
+        return this._isDSTShifted;
+    }
+
+    var c = {},
+        other;
+
+    copyConfig(c, this);
+    c = prepareConfig(c);
+
+    if (c._a) {
+        other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
+        this._isDSTShifted =
+            this.isValid() && compareArrays(c._a, other.toArray()) > 0;
+    } else {
+        this._isDSTShifted = false;
+    }
+
+    return this._isDSTShifted;
+}
+
+export function isLocal() {
+    return this.isValid() ? !this._isUTC : false;
+}
+
+export function isUtcOffset() {
+    return this.isValid() ? this._isUTC : false;
+}
+
+export function isUtc() {
+    return this.isValid() ? this._isUTC && this._offset === 0 : false;
+}

package/WeatherAPI/node_modules/moment/src/lib/units/priorities.js

@@ -0,0 +1,34 @@
+import hasOwnProp from '../utils/has-own-prop';
+
+var priorities = {
+    date: 9,
+    day: 11,
+    weekday: 11,
+    isoWeekday: 11,
+    dayOfYear: 4,
+    hour: 13,
+    millisecond: 16,
+    minute: 14,
+    month: 8,
+    quarter: 7,
+    second: 15,
+    weekYear: 1,
+    isoWeekYear: 1,
+    week: 5,
+    isoWeek: 5,
+    year: 1,
+};
+
+export function getPrioritizedUnits(unitsObj) {
+    var units = [],
+        u;
+    for (u in unitsObj) {
+        if (hasOwnProp(unitsObj, u)) {
+            units.push({ unit: u, priority: priorities[u] });
+        }
+    }
+    units.sort(function (a, b) {
+        return a.priority - b.priority;
+    });
+    return units;
+}

package/WeatherAPI/node_modules/moment/src/lib/units/quarter.js

@@ -0,0 +1,24 @@
+import { addFormatToken } from '../format/format';
+import { addRegexToken, match1 } from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { MONTH } from './constants';
+import toInt from '../utils/to-int';
+
+// FORMATTING
+
+addFormatToken('Q', 0, 'Qo', 'quarter');
+
+// PARSING
+
+addRegexToken('Q', match1);
+addParseToken('Q', function (input, array) {
+    array[MONTH] = (toInt(input) - 1) * 3;
+});
+
+// MOMENTS
+
+export function getSetQuarter(input) {
+    return input == null
+        ? Math.ceil((this.month() + 1) / 3)
+        : this.month((input - 1) * 3 + (this.month() % 3));
+}

package/WeatherAPI/node_modules/moment/src/lib/units/second.js

@@ -0,0 +1,24 @@
+import { makeGetSet } from '../moment/get-set';
+import { addFormatToken } from '../format/format';
+import {
+    addRegexToken,
+    match1to2,
+    match2,
+    match1to2HasZero,
+} from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { SECOND } from './constants';
+
+// FORMATTING
+
+addFormatToken('s', ['ss', 2], 0, 'second');
+
+// PARSING
+
+addRegexToken('s', match1to2, match1to2HasZero);
+addRegexToken('ss', match1to2, match2);
+addParseToken(['s', 'ss'], SECOND);
+
+// MOMENTS
+
+export var getSetSecond = makeGetSet('Seconds', false);

package/WeatherAPI/node_modules/moment/src/lib/units/timestamp.js

@@ -0,0 +1,20 @@
+import { addFormatToken } from '../format/format';
+import { addRegexToken, matchTimestamp, matchSigned } from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import toInt from '../utils/to-int';
+
+// FORMATTING
+
+addFormatToken('X', 0, 0, 'unix');
+addFormatToken('x', 0, 0, 'valueOf');
+
+// PARSING
+
+addRegexToken('x', matchSigned);
+addRegexToken('X', matchTimestamp);
+addParseToken('X', function (input, array, config) {
+    config._d = new Date(parseFloat(input) * 1000);
+});
+addParseToken('x', function (input, array, config) {
+    config._d = new Date(toInt(input));
+});

package/WeatherAPI/node_modules/moment/src/lib/units/timezone.js

@@ -0,0 +1,16 @@
+import { addFormatToken } from '../format/format';
+
+// FORMATTING
+
+addFormatToken('z', 0, 0, 'zoneAbbr');
+addFormatToken('zz', 0, 0, 'zoneName');
+
+// MOMENTS
+
+export function getZoneAbbr() {
+    return this._isUTC ? 'UTC' : '';
+}
+
+export function getZoneName() {
+    return this._isUTC ? 'Coordinated Universal Time' : '';
+}