cbs-block 1.0.8 → 1.0.10

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

@@ -0,0 +1,28 @@
+import { createLocal } from '../create/local';
+import { createUTC } from '../create/utc';
+import { createInvalid } from '../create/valid';
+import { isMoment } from './constructor';
+import { min, max } from './min-max';
+import { now } from './now';
+import momentPrototype from './prototype';
+
+function createUnix(input) {
+    return createLocal(input * 1000);
+}
+
+function createInZone() {
+    return createLocal.apply(null, arguments).parseZone();
+}
+
+export {
+    now,
+    min,
+    max,
+    isMoment,
+    createUTC,
+    createUnix,
+    createLocal,
+    createInZone,
+    createInvalid,
+    momentPrototype,
+};

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

@@ -0,0 +1,3 @@
+export var now = function () {
+    return Date.now ? Date.now() : +new Date();
+};

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

@@ -0,0 +1,197 @@
+import { Moment } from './constructor';
+
+var proto = Moment.prototype;
+
+import { add, subtract } from './add-subtract';
+import { calendar } from './calendar';
+import { clone } from './clone';
+import {
+    isBefore,
+    isBetween,
+    isSame,
+    isAfter,
+    isSameOrAfter,
+    isSameOrBefore,
+} from './compare';
+import { diff } from './diff';
+import { format, toString, toISOString, inspect } from './format';
+import { from, fromNow } from './from';
+import { to, toNow } from './to';
+import { stringGet, stringSet } from './get-set';
+import { locale, localeData, lang } from './locale';
+import { prototypeMin, prototypeMax } from './min-max';
+import { startOf, endOf } from './start-end-of';
+import { valueOf, toDate, toArray, toObject, toJSON, unix } from './to-type';
+import { isValid, parsingFlags, invalidAt } from './valid';
+import { creationData } from './creation-data';
+
+proto.add = add;
+proto.calendar = calendar;
+proto.clone = clone;
+proto.diff = diff;
+proto.endOf = endOf;
+proto.format = format;
+proto.from = from;
+proto.fromNow = fromNow;
+proto.to = to;
+proto.toNow = toNow;
+proto.get = stringGet;
+proto.invalidAt = invalidAt;
+proto.isAfter = isAfter;
+proto.isBefore = isBefore;
+proto.isBetween = isBetween;
+proto.isSame = isSame;
+proto.isSameOrAfter = isSameOrAfter;
+proto.isSameOrBefore = isSameOrBefore;
+proto.isValid = isValid;
+proto.lang = lang;
+proto.locale = locale;
+proto.localeData = localeData;
+proto.max = prototypeMax;
+proto.min = prototypeMin;
+proto.parsingFlags = parsingFlags;
+proto.set = stringSet;
+proto.startOf = startOf;
+proto.subtract = subtract;
+proto.toArray = toArray;
+proto.toObject = toObject;
+proto.toDate = toDate;
+proto.toISOString = toISOString;
+proto.inspect = inspect;
+if (typeof Symbol !== 'undefined' && Symbol.for != null) {
+    proto[Symbol.for('nodejs.util.inspect.custom')] = function () {
+        return 'Moment<' + this.format() + '>';
+    };
+}
+proto.toJSON = toJSON;
+proto.toString = toString;
+proto.unix = unix;
+proto.valueOf = valueOf;
+proto.creationData = creationData;
+
+// Era
+import { getEraName, getEraNarrow, getEraAbbr, getEraYear } from '../units/era';
+proto.eraName = getEraName;
+proto.eraNarrow = getEraNarrow;
+proto.eraAbbr = getEraAbbr;
+proto.eraYear = getEraYear;
+
+// Year
+import { getSetYear, getIsLeapYear } from '../units/year';
+proto.year = getSetYear;
+proto.isLeapYear = getIsLeapYear;
+
+// Week Year
+import {
+    getSetWeekYear,
+    getSetISOWeekYear,
+    getWeeksInYear,
+    getWeeksInWeekYear,
+    getISOWeeksInYear,
+    getISOWeeksInISOWeekYear,
+} from '../units/week-year';
+proto.weekYear = getSetWeekYear;
+proto.isoWeekYear = getSetISOWeekYear;
+
+// Quarter
+import { getSetQuarter } from '../units/quarter';
+proto.quarter = proto.quarters = getSetQuarter;
+
+// Month
+import { getSetMonth, getDaysInMonth } from '../units/month';
+proto.month = getSetMonth;
+proto.daysInMonth = getDaysInMonth;
+
+// Week
+import { getSetWeek, getSetISOWeek } from '../units/week';
+proto.week = proto.weeks = getSetWeek;
+proto.isoWeek = proto.isoWeeks = getSetISOWeek;
+proto.weeksInYear = getWeeksInYear;
+proto.weeksInWeekYear = getWeeksInWeekYear;
+proto.isoWeeksInYear = getISOWeeksInYear;
+proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
+
+// Day
+import { getSetDayOfMonth } from '../units/day-of-month';
+import {
+    getSetDayOfWeek,
+    getSetISODayOfWeek,
+    getSetLocaleDayOfWeek,
+} from '../units/day-of-week';
+import { getSetDayOfYear } from '../units/day-of-year';
+proto.date = getSetDayOfMonth;
+proto.day = proto.days = getSetDayOfWeek;
+proto.weekday = getSetLocaleDayOfWeek;
+proto.isoWeekday = getSetISODayOfWeek;
+proto.dayOfYear = getSetDayOfYear;
+
+// Hour
+import { getSetHour } from '../units/hour';
+proto.hour = proto.hours = getSetHour;
+
+// Minute
+import { getSetMinute } from '../units/minute';
+proto.minute = proto.minutes = getSetMinute;
+
+// Second
+import { getSetSecond } from '../units/second';
+proto.second = proto.seconds = getSetSecond;
+
+// Millisecond
+import { getSetMillisecond } from '../units/millisecond';
+proto.millisecond = proto.milliseconds = getSetMillisecond;
+
+// Offset
+import {
+    getSetOffset,
+    setOffsetToUTC,
+    setOffsetToLocal,
+    setOffsetToParsedOffset,
+    hasAlignedHourOffset,
+    isDaylightSavingTime,
+    isDaylightSavingTimeShifted,
+    getSetZone,
+    isLocal,
+    isUtcOffset,
+    isUtc,
+} from '../units/offset';
+proto.utcOffset = getSetOffset;
+proto.utc = setOffsetToUTC;
+proto.local = setOffsetToLocal;
+proto.parseZone = setOffsetToParsedOffset;
+proto.hasAlignedHourOffset = hasAlignedHourOffset;
+proto.isDST = isDaylightSavingTime;
+proto.isLocal = isLocal;
+proto.isUtcOffset = isUtcOffset;
+proto.isUtc = isUtc;
+proto.isUTC = isUtc;
+
+// Timezone
+import { getZoneAbbr, getZoneName } from '../units/timezone';
+proto.zoneAbbr = getZoneAbbr;
+proto.zoneName = getZoneName;
+
+// Deprecations
+import { deprecate } from '../utils/deprecate';
+proto.dates = deprecate(
+    'dates accessor is deprecated. Use date instead.',
+    getSetDayOfMonth
+);
+proto.months = deprecate(
+    'months accessor is deprecated. Use month instead',
+    getSetMonth
+);
+proto.years = deprecate(
+    'years accessor is deprecated. Use year instead',
+    getSetYear
+);
+proto.zone = deprecate(
+    'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',
+    getSetZone
+);
+proto.isDSTShifted = deprecate(
+    'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',
+    isDaylightSavingTimeShifted
+);
+
+export default proto;

package/WeatherAPI/node_modules/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;
+}

package/WeatherAPI/node_modules/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;
+}

package/WeatherAPI/node_modules/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);
+}

package/WeatherAPI/node_modules/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;
+}

package/WeatherAPI/node_modules/moment/src/lib/parse/regex.js

@@ -0,0 +1,84 @@
+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,
+    match1to2NoLeadingZero = /^[1-9]\d?/, //         1-99
+    match1to2HasZero = /^([1-9]\d|\d)/, //           0-99
+    regexes;
+
+export {
+    match1,
+    match2,
+    match3,
+    match4,
+    match6,
+    match1to2,
+    match3to4,
+    match5to6,
+    match1to3,
+    match1to4,
+    match1to6,
+    matchUnsigned,
+    matchSigned,
+    matchOffset,
+    matchShortOffset,
+    matchTimestamp,
+    matchWord,
+    match1to2NoLeadingZero,
+    match1to2HasZero,
+};
+
+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, '\\$&');
+}

package/WeatherAPI/node_modules/moment/src/lib/parse/token.js

@@ -0,0 +1,36 @@
+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,
+        tokenLen;
+    if (typeof token === 'string') {
+        token = [token];
+    }
+    if (isNumber(callback)) {
+        func = function (input, array) {
+            array[callback] = toInt(input);
+        };
+    }
+    tokenLen = token.length;
+    for (i = 0; i < tokenLen; 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);
+    }
+}

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

@@ -0,0 +1,75 @@
+import hasOwnProp from '../utils/has-own-prop';
+
+var aliases = {
+    D: 'date',
+    dates: 'date',
+    date: 'date',
+    d: 'day',
+    days: 'day',
+    day: 'day',
+    e: 'weekday',
+    weekdays: 'weekday',
+    weekday: 'weekday',
+    E: 'isoWeekday',
+    isoweekdays: 'isoWeekday',
+    isoweekday: 'isoWeekday',
+    DDD: 'dayOfYear',
+    dayofyears: 'dayOfYear',
+    dayofyear: 'dayOfYear',
+    h: 'hour',
+    hours: 'hour',
+    hour: 'hour',
+    ms: 'millisecond',
+    milliseconds: 'millisecond',
+    millisecond: 'millisecond',
+    m: 'minute',
+    minutes: 'minute',
+    minute: 'minute',
+    M: 'month',
+    months: 'month',
+    month: 'month',
+    Q: 'quarter',
+    quarters: 'quarter',
+    quarter: 'quarter',
+    s: 'second',
+    seconds: 'second',
+    second: 'second',
+    gg: 'weekYear',
+    weekyears: 'weekYear',
+    weekyear: 'weekYear',
+    GG: 'isoWeekYear',
+    isoweekyears: 'isoWeekYear',
+    isoweekyear: 'isoWeekYear',
+    w: 'week',
+    weeks: 'week',
+    week: 'week',
+    W: 'isoWeek',
+    isoweeks: 'isoWeek',
+    isoweek: 'isoWeek',
+    y: 'year',
+    years: 'year',
+    year: 'year',
+};
+
+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;
+}

package/WeatherAPI/node_modules/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;