cbs-block 1.0.8 → 1.0.10

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

@@ -0,0 +1,20 @@
+// Side effect imports
+import './day-of-month';
+import './day-of-week';
+import './day-of-year';
+import './hour';
+import './millisecond';
+import './minute';
+import './month';
+import './offset';
+import './quarter';
+import './second';
+import './timestamp';
+import './timezone';
+import './week-year';
+import './week';
+import './year';
+
+import { normalizeUnits } from './aliases';
+
+export { normalizeUnits };

package/WeatherAPI/node_modules/moment/src/lib/units/week-calendar-utils.js

@@ -0,0 +1,66 @@
+import { daysInYear } from './year';
+import { createUTCDate } from '../create/date-from-array';
+
+// start-of-first-week - start-of-year
+function firstWeekOffset(year, dow, doy) {
+    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
+        fwd = 7 + dow - doy,
+        // first-week day local weekday -- which local weekday is fwd
+        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
+
+    return -fwdlw + fwd - 1;
+}
+
+// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+export function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+    var localWeekday = (7 + weekday - dow) % 7,
+        weekOffset = firstWeekOffset(year, dow, doy),
+        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
+        resYear,
+        resDayOfYear;
+
+    if (dayOfYear <= 0) {
+        resYear = year - 1;
+        resDayOfYear = daysInYear(resYear) + dayOfYear;
+    } else if (dayOfYear > daysInYear(year)) {
+        resYear = year + 1;
+        resDayOfYear = dayOfYear - daysInYear(year);
+    } else {
+        resYear = year;
+        resDayOfYear = dayOfYear;
+    }
+
+    return {
+        year: resYear,
+        dayOfYear: resDayOfYear,
+    };
+}
+
+export function weekOfYear(mom, dow, doy) {
+    var weekOffset = firstWeekOffset(mom.year(), dow, doy),
+        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
+        resWeek,
+        resYear;
+
+    if (week < 1) {
+        resYear = mom.year() - 1;
+        resWeek = week + weeksInYear(resYear, dow, doy);
+    } else if (week > weeksInYear(mom.year(), dow, doy)) {
+        resWeek = week - weeksInYear(mom.year(), dow, doy);
+        resYear = mom.year() + 1;
+    } else {
+        resYear = mom.year();
+        resWeek = week;
+    }
+
+    return {
+        week: resWeek,
+        year: resYear,
+    };
+}
+
+export function weeksInYear(year, dow, doy) {
+    var weekOffset = firstWeekOffset(year, dow, doy),
+        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+}

package/WeatherAPI/node_modules/moment/src/lib/units/week-year.js

@@ -0,0 +1,128 @@
+import { addFormatToken } from '../format/format';
+import {
+    addRegexToken,
+    match1to2,
+    match1to4,
+    match1to6,
+    match2,
+    match4,
+    match6,
+    matchSigned,
+} from '../parse/regex';
+import { addWeekParseToken } from '../parse/token';
+import {
+    weekOfYear,
+    weeksInYear,
+    dayOfYearFromWeeks,
+} from './week-calendar-utils';
+import toInt from '../utils/to-int';
+import { hooks } from '../utils/hooks';
+import { createUTCDate } from '../create/date-from-array';
+
+// FORMATTING
+
+addFormatToken(0, ['gg', 2], 0, function () {
+    return this.weekYear() % 100;
+});
+
+addFormatToken(0, ['GG', 2], 0, function () {
+    return this.isoWeekYear() % 100;
+});
+
+function addWeekYearFormatToken(token, getter) {
+    addFormatToken(0, [token, token.length], 0, getter);
+}
+
+addWeekYearFormatToken('gggg', 'weekYear');
+addWeekYearFormatToken('ggggg', 'weekYear');
+addWeekYearFormatToken('GGGG', 'isoWeekYear');
+addWeekYearFormatToken('GGGGG', 'isoWeekYear');
+
+// ALIASES
+
+// PARSING
+
+addRegexToken('G', matchSigned);
+addRegexToken('g', matchSigned);
+addRegexToken('GG', match1to2, match2);
+addRegexToken('gg', match1to2, match2);
+addRegexToken('GGGG', match1to4, match4);
+addRegexToken('gggg', match1to4, match4);
+addRegexToken('GGGGG', match1to6, match6);
+addRegexToken('ggggg', match1to6, match6);
+
+addWeekParseToken(
+    ['gggg', 'ggggg', 'GGGG', 'GGGGG'],
+    function (input, week, config, token) {
+        week[token.substr(0, 2)] = toInt(input);
+    }
+);
+
+addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
+    week[token] = hooks.parseTwoDigitYear(input);
+});
+
+// MOMENTS
+
+export function getSetWeekYear(input) {
+    return getSetWeekYearHelper.call(
+        this,
+        input,
+        this.week(),
+        this.weekday() + this.localeData()._week.dow,
+        this.localeData()._week.dow,
+        this.localeData()._week.doy
+    );
+}
+
+export function getSetISOWeekYear(input) {
+    return getSetWeekYearHelper.call(
+        this,
+        input,
+        this.isoWeek(),
+        this.isoWeekday(),
+        1,
+        4
+    );
+}
+
+export function getISOWeeksInYear() {
+    return weeksInYear(this.year(), 1, 4);
+}
+
+export function getISOWeeksInISOWeekYear() {
+    return weeksInYear(this.isoWeekYear(), 1, 4);
+}
+
+export function getWeeksInYear() {
+    var weekInfo = this.localeData()._week;
+    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
+}
+
+export function getWeeksInWeekYear() {
+    var weekInfo = this.localeData()._week;
+    return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
+}
+
+function getSetWeekYearHelper(input, week, weekday, dow, doy) {
+    var weeksTarget;
+    if (input == null) {
+        return weekOfYear(this, dow, doy).year;
+    } else {
+        weeksTarget = weeksInYear(input, dow, doy);
+        if (week > weeksTarget) {
+            week = weeksTarget;
+        }
+        return setWeekAll.call(this, input, week, weekday, dow, doy);
+    }
+}
+
+function setWeekAll(weekYear, week, weekday, dow, doy) {
+    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
+        date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
+
+    this.year(date.getUTCFullYear());
+    this.month(date.getUTCMonth());
+    this.date(date.getUTCDate());
+    return this;
+}

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

@@ -0,0 +1,62 @@
+import { addFormatToken } from '../format/format';
+import {
+    addRegexToken,
+    match1to2,
+    match2,
+    match1to2NoLeadingZero,
+} from '../parse/regex';
+import { addWeekParseToken } from '../parse/token';
+import toInt from '../utils/to-int';
+import { weekOfYear } from './week-calendar-utils';
+
+// FORMATTING
+
+addFormatToken('w', ['ww', 2], 'wo', 'week');
+addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
+
+// PARSING
+
+addRegexToken('w', match1to2, match1to2NoLeadingZero);
+addRegexToken('ww', match1to2, match2);
+addRegexToken('W', match1to2, match1to2NoLeadingZero);
+addRegexToken('WW', match1to2, match2);
+
+addWeekParseToken(
+    ['w', 'ww', 'W', 'WW'],
+    function (input, week, config, token) {
+        week[token.substr(0, 1)] = toInt(input);
+    }
+);
+
+// HELPERS
+
+// LOCALES
+
+export function localeWeek(mom) {
+    return weekOfYear(mom, this._week.dow, this._week.doy).week;
+}
+
+export var defaultLocaleWeek = {
+    dow: 0, // Sunday is the first day of the week.
+    doy: 6, // The week that contains Jan 6th is the first week of the year.
+};
+
+export function localeFirstDayOfWeek() {
+    return this._week.dow;
+}
+
+export function localeFirstDayOfYear() {
+    return this._week.doy;
+}
+
+// MOMENTS
+
+export function getSetWeek(input) {
+    var week = this.localeData().week(this);
+    return input == null ? week : this.add((input - week) * 7, 'd');
+}
+
+export function getSetISOWeek(input) {
+    var week = weekOfYear(this, 1, 4).week;
+    return input == null ? week : this.add((input - week) * 7, 'd');
+}

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

@@ -0,0 +1,75 @@
+import { makeGetSet } from '../moment/get-set';
+import { addFormatToken } from '../format/format';
+import {
+    addRegexToken,
+    match1to2,
+    match1to4,
+    match1to6,
+    match2,
+    match4,
+    match6,
+    matchSigned,
+} from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { isLeapYear } from '../utils/is-leap-year';
+import { hooks } from '../utils/hooks';
+import { YEAR } from './constants';
+import toInt from '../utils/to-int';
+import zeroFill from '../utils/zero-fill';
+
+// FORMATTING
+
+addFormatToken('Y', 0, 0, function () {
+    var y = this.year();
+    return y <= 9999 ? zeroFill(y, 4) : '+' + y;
+});
+
+addFormatToken(0, ['YY', 2], 0, function () {
+    return this.year() % 100;
+});
+
+addFormatToken(0, ['YYYY', 4], 0, 'year');
+addFormatToken(0, ['YYYYY', 5], 0, 'year');
+addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
+
+// PARSING
+
+addRegexToken('Y', matchSigned);
+addRegexToken('YY', match1to2, match2);
+addRegexToken('YYYY', match1to4, match4);
+addRegexToken('YYYYY', match1to6, match6);
+addRegexToken('YYYYYY', match1to6, match6);
+
+addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+addParseToken('YYYY', function (input, array) {
+    array[YEAR] =
+        input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+});
+addParseToken('YY', function (input, array) {
+    array[YEAR] = hooks.parseTwoDigitYear(input);
+});
+addParseToken('Y', function (input, array) {
+    array[YEAR] = parseInt(input, 10);
+});
+
+// HELPERS
+
+export function daysInYear(year) {
+    return isLeapYear(year) ? 366 : 365;
+}
+
+export { isLeapYear };
+
+// HOOKS
+
+hooks.parseTwoDigitYear = function (input) {
+    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+};
+
+// MOMENTS
+
+export var getSetYear = makeGetSet('FullYear', true);
+
+export function getIsLeapYear() {
+    return isLeapYear(this.year());
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/abs-ceil.js

@@ -0,0 +1,7 @@
+export default function absCeil(number) {
+    if (number < 0) {
+        return Math.floor(number);
+    } else {
+        return Math.ceil(number);
+    }
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/abs-floor.js

@@ -0,0 +1,8 @@
+export default function absFloor(number) {
+    if (number < 0) {
+        // -0 -> 0
+        return Math.ceil(number) || 0;
+    } else {
+        return Math.floor(number);
+    }
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/abs-round.js

@@ -0,0 +1,7 @@
+export default function absRound(number) {
+    if (number < 0) {
+        return Math.round(-1 * number) * -1;
+    } else {
+        return Math.round(number);
+    }
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/compare-arrays.js

@@ -0,0 +1,18 @@
+import toInt from './to-int';
+
+// compare two arrays, return the number of differences
+export default function compareArrays(array1, array2, dontConvert) {
+    var len = Math.min(array1.length, array2.length),
+        lengthDiff = Math.abs(array1.length - array2.length),
+        diffs = 0,
+        i;
+    for (i = 0; i < len; i++) {
+        if (
+            (dontConvert && array1[i] !== array2[i]) ||
+            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))
+        ) {
+            diffs++;
+        }
+    }
+    return diffs + lengthDiff;
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/defaults.js

@@ -0,0 +1,10 @@
+// Pick the first defined of two or three arguments.
+export default function defaults(a, b, c) {
+    if (a != null) {
+        return a;
+    }
+    if (b != null) {
+        return b;
+    }
+    return c;
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/deprecate.js

@@ -0,0 +1,69 @@
+import extend from './extend';
+import { hooks } from './hooks';
+import hasOwnProp from './has-own-prop';
+
+function warn(msg) {
+    if (
+        hooks.suppressDeprecationWarnings === false &&
+        typeof console !== 'undefined' &&
+        console.warn
+    ) {
+        console.warn('Deprecation warning: ' + msg);
+    }
+}
+
+export function deprecate(msg, fn) {
+    var firstTime = true;
+
+    return extend(function () {
+        if (hooks.deprecationHandler != null) {
+            hooks.deprecationHandler(null, msg);
+        }
+        if (firstTime) {
+            var args = [],
+                arg,
+                i,
+                key,
+                argLen = arguments.length;
+            for (i = 0; i < argLen; i++) {
+                arg = '';
+                if (typeof arguments[i] === 'object') {
+                    arg += '\n[' + i + '] ';
+                    for (key in arguments[0]) {
+                        if (hasOwnProp(arguments[0], key)) {
+                            arg += key + ': ' + arguments[0][key] + ', ';
+                        }
+                    }
+                    arg = arg.slice(0, -2); // Remove trailing comma and space
+                } else {
+                    arg = arguments[i];
+                }
+                args.push(arg);
+            }
+            warn(
+                msg +
+                    '\nArguments: ' +
+                    Array.prototype.slice.call(args).join('') +
+                    '\n' +
+                    new Error().stack
+            );
+            firstTime = false;
+        }
+        return fn.apply(this, arguments);
+    }, fn);
+}
+
+var deprecations = {};
+
+export function deprecateSimple(name, msg) {
+    if (hooks.deprecationHandler != null) {
+        hooks.deprecationHandler(name, msg);
+    }
+    if (!deprecations[name]) {
+        warn(msg);
+        deprecations[name] = true;
+    }
+}
+
+hooks.suppressDeprecationWarnings = false;
+hooks.deprecationHandler = null;

package/WeatherAPI/node_modules/moment/src/lib/utils/extend.js

@@ -0,0 +1,19 @@
+import hasOwnProp from './has-own-prop';
+
+export default function extend(a, b) {
+    for (var i in b) {
+        if (hasOwnProp(b, i)) {
+            a[i] = b[i];
+        }
+    }
+
+    if (hasOwnProp(b, 'toString')) {
+        a.toString = b.toString;
+    }
+
+    if (hasOwnProp(b, 'valueOf')) {
+        a.valueOf = b.valueOf;
+    }
+
+    return a;
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/has-own-prop.js

@@ -0,0 +1,3 @@
+export default function hasOwnProp(a, b) {
+    return Object.prototype.hasOwnProperty.call(a, b);
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/hooks.js

@@ -0,0 +1,13 @@
+export { hooks, setHookCallback };
+
+var hookCallback;
+
+function hooks() {
+    return hookCallback.apply(null, arguments);
+}
+
+// This is done to register the method called with moment()
+// without creating circular dependencies.
+function setHookCallback(callback) {
+    hookCallback = callback;
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/index-of.js

@@ -0,0 +1,18 @@
+var indexOf;
+
+if (Array.prototype.indexOf) {
+    indexOf = Array.prototype.indexOf;
+} else {
+    indexOf = function (o) {
+        // I know
+        var i;
+        for (i = 0; i < this.length; ++i) {
+            if (this[i] === o) {
+                return i;
+            }
+        }
+        return -1;
+    };
+}
+
+export { indexOf as default };

package/WeatherAPI/node_modules/moment/src/lib/utils/is-array.js

@@ -0,0 +1,6 @@
+export default function isArray(input) {
+    return (
+        input instanceof Array ||
+        Object.prototype.toString.call(input) === '[object Array]'
+    );
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/is-calendar-spec.js

@@ -0,0 +1,25 @@
+import isObjectEmpty from './is-object-empty';
+import hasOwnProp from './has-own-prop';
+import isObject from './is-object';
+
+export default function isCalendarSpec(input) {
+    var objectTest = isObject(input) && !isObjectEmpty(input),
+        propertyTest = false,
+        properties = [
+            'sameDay',
+            'nextDay',
+            'lastDay',
+            'nextWeek',
+            'lastWeek',
+            'sameElse',
+        ],
+        i,
+        property;
+
+    for (i = 0; i < properties.length; i += 1) {
+        property = properties[i];
+        propertyTest = propertyTest || hasOwnProp(input, property);
+    }
+
+    return objectTest && propertyTest;
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/is-date.js

@@ -0,0 +1,6 @@
+export default function isDate(input) {
+    return (
+        input instanceof Date ||
+        Object.prototype.toString.call(input) === '[object Date]'
+    );
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/is-function.js

@@ -0,0 +1,6 @@
+export default function isFunction(input) {
+    return (
+        (typeof Function !== 'undefined' && input instanceof Function) ||
+        Object.prototype.toString.call(input) === '[object Function]'
+    );
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/is-leap-year.js

@@ -0,0 +1,3 @@
+export function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/is-moment-input.js

@@ -0,0 +1,75 @@
+import isObjectEmpty from './is-object-empty';
+import hasOwnProp from './has-own-prop';
+import isObject from './is-object';
+import isDate from './is-date';
+import isNumber from './is-number';
+import isString from './is-string';
+import { isMoment } from '../moment/constructor';
+import isArray from './is-array';
+
+// type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined
+export function isMomentInput(input) {
+    return (
+        isMoment(input) ||
+        isDate(input) ||
+        isString(input) ||
+        isNumber(input) ||
+        isNumberOrStringArray(input) ||
+        isMomentInputObject(input) ||
+        input === null ||
+        input === undefined
+    );
+}
+
+export function isMomentInputObject(input) {
+    var objectTest = isObject(input) && !isObjectEmpty(input),
+        propertyTest = false,
+        properties = [
+            'years',
+            'year',
+            'y',
+            'months',
+            'month',
+            'M',
+            'days',
+            'day',
+            'd',
+            'dates',
+            'date',
+            'D',
+            'hours',
+            'hour',
+            'h',
+            'minutes',
+            'minute',
+            'm',
+            'seconds',
+            'second',
+            's',
+            'milliseconds',
+            'millisecond',
+            'ms',
+        ],
+        i,
+        property,
+        propertyLen = properties.length;
+
+    for (i = 0; i < propertyLen; i += 1) {
+        property = properties[i];
+        propertyTest = propertyTest || hasOwnProp(input, property);
+    }
+
+    return objectTest && propertyTest;
+}
+
+function isNumberOrStringArray(input) {
+    var arrayTest = isArray(input),
+        dataTypeTest = false;
+    if (arrayTest) {
+        dataTypeTest =
+            input.filter(function (item) {
+                return !isNumber(item) && isString(input);
+            }).length === 0;
+    }
+    return arrayTest && dataTypeTest;
+}

package/WeatherAPI/node_modules/moment/src/lib/utils/is-number.js

@@ -0,0 +1,6 @@
+export default function isNumber(input) {
+    return (
+        typeof input === 'number' ||
+        Object.prototype.toString.call(input) === '[object Number]'
+    );
+}