card-mod-date 0.15.4 → 0.15.6

data/vendor/moment/package.js

@@ -0,0 +1,11 @@
+var profile = {
+    resourceTags: {
+        ignore: function(filename, mid){
+            // only include moment/moment
+            return mid != "moment/moment";
+        },
+        amd: function(filename, mid){
+            return /\.js$/.test(filename);
+        }
+    }
+};

data/vendor/moment/package.json

@@ -0,0 +1,112 @@
+{
+    "name": "moment",
+    "version": "2.29.0",
+    "description": "Parse, validate, manipulate, and display dates",
+    "homepage": "https://momentjs.com",
+    "author": "Iskren Ivov Chernev <iskren.chernev@gmail.com> (https://github.com/ichernev)",
+    "contributors": [
+        "Tim Wood <washwithcare@gmail.com> (http://timwoodcreates.com/)",
+        "Rocky Meza (http://rockymeza.com)",
+        "Matt Johnson <mj1856@hotmail.com> (http://codeofmatt.com)",
+        "Isaac Cambron <isaac@isaaccambron.com> (http://isaaccambron.com)",
+        "Andre Polykanine <andre@oire.org> (https://github.com/oire)"
+    ],
+    "keywords": [
+        "moment",
+        "date",
+        "time",
+        "parse",
+        "format",
+        "validate",
+        "i18n",
+        "l10n",
+        "ender"
+    ],
+    "main": "./moment.js",
+    "jsnext:main": "./dist/moment.js",
+    "typings": "./moment.d.ts",
+    "typesVersions": {
+        ">=3.1": {
+            "*": [
+                "ts3.1-typings/*"
+            ]
+        }
+    },
+    "engines": {
+        "node": "*"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/moment/moment.git"
+    },
+    "bugs": {
+        "url": "https://github.com/moment/moment/issues"
+    },
+    "license": "MIT",
+    "devDependencies": {
+        "benchmark": "latest",
+        "coveralls": "latest",
+        "cross-env": "^6.0.3",
+        "es6-promise": "latest",
+        "eslint": "~6",
+        "grunt": "latest",
+        "grunt-benchmark": "latest",
+        "grunt-cli": "latest",
+        "grunt-contrib-clean": "latest",
+        "grunt-contrib-concat": "latest",
+        "grunt-contrib-copy": "latest",
+        "grunt-contrib-uglify": "latest",
+        "grunt-contrib-watch": "latest",
+        "grunt-env": "latest",
+        "grunt-exec": "latest",
+        "grunt-karma": "latest",
+        "grunt-nuget": "latest",
+        "grunt-string-replace": "latest",
+        "karma": "latest",
+        "karma-chrome-launcher": "latest",
+        "karma-firefox-launcher": "latest",
+        "karma-qunit": "latest",
+        "karma-sauce-launcher": "4.1.4",
+        "load-grunt-tasks": "latest",
+        "lodash": ">=4.17.19",
+        "node-qunit": "latest",
+        "nyc": "latest",
+        "prettier": "latest",
+        "qunit": "^2.10.0",
+        "rollup": "2.17.1",
+        "typescript": "^1.8.10",
+        "typescript3": "npm:typescript@^3.1.6",
+        "uglify-js": "latest"
+    },
+    "ender": "./ender.js",
+    "dojoBuild": "package.js",
+    "jspm": {
+        "files": [
+            "moment.js",
+            "moment.d.ts",
+            "locale"
+        ],
+        "map": {
+            "moment": "./moment"
+        },
+        "buildConfig": {
+            "uglify": true
+        }
+    },
+    "scripts": {
+        "ts3.1-typescript-test": "cross-env node_modules/typescript3/bin/tsc --project ts3.1-typing-tests",
+        "typescript-test": "cross-env node_modules/typescript/bin/tsc --project typing-tests",
+        "test": "grunt test",
+        "eslint": "eslint Gruntfile.js tasks src",
+        "prettier-check": "prettier --check Gruntfile.js tasks src",
+        "prettier-fmt": "prettier --write Gruntfile.js tasks src",
+        "coverage": "nyc npm test && nyc report",
+        "coveralls": "nyc npm test && nyc report --reporter=text-lcov | coveralls"
+    },
+    "spm": {
+        "main": "moment.js",
+        "output": [
+            "locale/*.js"
+        ]
+    }
+}

data/vendor/moment/scripts/locales.js

@@ -0,0 +1,146 @@
+var fs = require('fs'),
+    path = require('path'),
+    https = require('https');
+
+var localeDir = path.join('src', 'locale');
+
+var args = process.argv.slice(2);
+
+function help() {
+    console.log(process.argv[1], '[list|mention|find-commenters] ARGS');
+    console.log();
+    console.log('    list      show all authors in all locales');
+    console.log('    mention   show all authors in all locales, ready to copy-paste in github issue');
+    console.log('    find-commenters #ID  finds all people that participated in a github conversation');
+}
+
+function extract() {
+    var authors = {};
+    fs.readdirSync(localeDir).forEach(function (locale) {
+        var content = fs.readFileSync(path.join(localeDir, locale), {encoding: 'utf-8'}),
+            localeCode = locale.split('.')[0],
+            localeAuthors = [];
+        content.split('\n').forEach(function (line) {
+            var match = line.match(/^\/\/! author.*github[.]com\/(.*)$/);
+            if (match !== null) {
+                // console.log("  ", line);
+                localeAuthors.push(match[1]);
+            }
+        });
+        if (localeAuthors.length === 0) {
+            // use to debug
+            content.split('\n').forEach(function (line) {
+                var match = line.match(/^\/\/! author(.*)$/);
+                if (match !== null) {
+                    localeAuthors.push('---' + match[1]);
+                }
+            });
+            console.log(localeCode, localeAuthors);
+        } else {
+            authors[localeCode] = localeAuthors;
+        }
+    });
+    return authors;
+}
+
+function list() {
+    var authors = extract();
+    Object.keys(authors).forEach(function (localeCode) {
+        console.log(localeCode, authors[localeCode]);
+    });
+}
+
+function mention() {
+    var authors = extract();
+    Object.keys(authors).forEach(function (localeCode) {
+        console.log('- [ ]', localeCode, authors[localeCode].map(function (author) { return '@' + author; }).join(' '));
+    });
+}
+
+function findCommenters(postId) {
+
+    function fetchComments(page, callback) {
+        var options = {
+                hostname: 'api.github.com',
+                port: 443,
+                path: '/repos/moment/moment/issues/' + postId + '/comments?page=' + page,
+                method: 'GET',
+                headers: {
+                    'User-Agent': 'node script'
+                }
+            },
+            links = {};
+        console.log('fetching', options.path);
+        https.get(options, function (res) {
+            if ('link' in res.headers) {
+                res.headers.link.split(', ').forEach(function(linkStr) {
+                    var pieces = linkStr.split('; ');
+                    var key = pieces[1].split('=')[1];
+                    var link = pieces[0];
+                    key = key.substr(1, key.length - 2);
+                    link = link.substr(1, link.length - 2);
+                    links[key] = link;
+                });
+            }
+            var bodyChunks = [], body;
+            res.on('data', function (chunk) {
+                bodyChunks.push(chunk);
+            });
+            res.on('end', function () {
+                body = bodyChunks.join('');
+                callback(page, JSON.parse(body), links);
+            });
+        });
+    }
+
+    var commenters = {};
+    var maxPage = 1;
+    fetchComments(1, function (page, body, links) {
+        handleBody(body, page);
+        if ('last' in links) {
+            maxPage = parseInt(links.last.split('=')[1], 10);
+        }
+        var pagesLeft = maxPage - 1;
+        for (var p = 2; p <= maxPage; p += 1) {
+            fetchComments(p, function (page, body, links) {
+                handleBody(body, page);
+                pagesLeft -= 1;
+                if (pagesLeft === 0) {
+                    handleCommenters(Object.keys(commenters));
+                }
+            });
+        }
+    });
+
+    function handleBody(body, page) {
+        body.forEach(function (comment) {
+            console.log(page, comment.user.login);
+            commenters[comment.user.login] = 1;
+        });
+    }
+
+    function handleCommenters(commenters) {
+        console.log('len of commenters', commenters.length);
+        console.log(commenters);
+    }
+}
+
+if (args.length === 0) {
+    help();
+    process.exit(0);
+}
+
+switch (args[0]) {
+    case 'list':
+        list();
+        break;
+    case 'mention':
+        mention();
+        break;
+    case 'find-commenters':
+        findCommenters(args[1]);
+        break;
+    default:
+        console.log('unknown argument', args[0]);
+        break;
+}

data/vendor/moment/scripts/npm_prepublish.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+set -e
+
+if [ "$#" != 1 ]; then
+    echo "Please provide tag to checkout" >&2
+    exit 1
+fi
+tag="$1"
+
+while [ "$PWD" != '/' -a ! -f moment.js ]; do
+    cd ..
+done
+
+if [ ! -f moment.js ]; then
+    echo "Run me from the moment repo" >&2
+    exit 1
+fi
+
+basename=$(basename $PWD)
+src=moment-npm-git
+dest=moment-npm
+
+cd ..
+
+rm -rf $src $dest
+
+git clone $basename $src
+mkdir $dest
+
+
+cp $src/moment.js $dest
+cp $src/moment.d.ts $dest
+cp $src/package.json $dest
+cp $src/README.md $dest
+cp $src/CHANGELOG.md $dest
+cp $src/LICENSE $dest
+cp -r $src/locale $dest
+cp -r $src/min $dest
+cp -r $src/src $dest && rm -r $dest/src/test
+cp $src/ender.js $dest
+cp $src/package.js $dest
+cp $src/.npmignore $dest
+cp -r $src/ts3.1-typings $dest
+cp -r $src/dist $dest
+
+rm -rf $src
+
+echo "Check out $dest"

data/vendor/moment/src/lib/create/check-overflow.js

@@ -0,0 +1,57 @@
+import { daysInMonth } from '../units/month';
+import {
+    YEAR,
+    MONTH,
+    DATE,
+    HOUR,
+    MINUTE,
+    SECOND,
+    MILLISECOND,
+    WEEK,
+    WEEKDAY,
+} from '../units/constants';
+import getParsingFlags from '../create/parsing-flags';
+
+export default function checkOverflow(m) {
+    var overflow,
+        a = m._a;
+
+    if (a && getParsingFlags(m).overflow === -2) {
+        overflow =
+            a[MONTH] < 0 || a[MONTH] > 11
+                ? MONTH
+                : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
+                ? DATE
+                : a[HOUR] < 0 ||
+                  a[HOUR] > 24 ||
+                  (a[HOUR] === 24 &&
+                      (a[MINUTE] !== 0 ||
+                          a[SECOND] !== 0 ||
+                          a[MILLISECOND] !== 0))
+                ? HOUR
+                : a[MINUTE] < 0 || a[MINUTE] > 59
+                ? MINUTE
+                : a[SECOND] < 0 || a[SECOND] > 59
+                ? SECOND
+                : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
+                ? MILLISECOND
+                : -1;
+
+        if (
+            getParsingFlags(m)._overflowDayOfYear &&
+            (overflow < YEAR || overflow > DATE)
+        ) {
+            overflow = DATE;
+        }
+        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
+            overflow = WEEK;
+        }
+        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
+            overflow = WEEKDAY;
+        }
+
+        getParsingFlags(m).overflow = overflow;
+    }
+
+    return m;
+}

data/vendor/moment/src/lib/create/date-from-array.js

@@ -0,0 +1,35 @@
+export function createDate(y, m, d, h, M, s, ms) {
+    // can't just apply() to create a date:
+    // https://stackoverflow.com/q/181348
+    var date;
+    // 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
+        date = new Date(y + 400, m, d, h, M, s, ms);
+        if (isFinite(date.getFullYear())) {
+            date.setFullYear(y);
+        }
+    } else {
+        date = new Date(y, m, d, h, M, s, ms);
+    }
+
+    return date;
+}
+
+export function createUTCDate(y) {
+    var date, args;
+    // the Date.UTC function remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        args = Array.prototype.slice.call(arguments);
+        // preserve leap years using a full 400 year cycle, then reset
+        args[0] = y + 400;
+        date = new Date(Date.UTC.apply(null, args));
+        if (isFinite(date.getUTCFullYear())) {
+            date.setUTCFullYear(y);
+        }
+    } else {
+        date = new Date(Date.UTC.apply(null, arguments));
+    }
+
+    return date;
+}

data/vendor/moment/src/lib/create/from-anything.js

@@ -0,0 +1,117 @@
+import isArray from '../utils/is-array';
+import isObject from '../utils/is-object';
+import isObjectEmpty from '../utils/is-object-empty';
+import isUndefined from '../utils/is-undefined';
+import isNumber from '../utils/is-number';
+import isDate from '../utils/is-date';
+import map from '../utils/map';
+import { createInvalid } from './valid';
+import { Moment, isMoment } from '../moment/constructor';
+import { getLocale } from '../locale/locales';
+import { hooks } from '../utils/hooks';
+import checkOverflow from './check-overflow';
+import { isValid } from './valid';
+
+import { configFromStringAndArray } from './from-string-and-array';
+import { configFromStringAndFormat } from './from-string-and-format';
+import { configFromString } from './from-string';
+import { configFromArray } from './from-array';
+import { configFromObject } from './from-object';
+
+function createFromConfig(config) {
+    var res = new Moment(checkOverflow(prepareConfig(config)));
+    if (res._nextDay) {
+        // Adding is smart enough around DST
+        res.add(1, 'd');
+        res._nextDay = undefined;
+    }
+
+    return res;
+}
+
+export function prepareConfig(config) {
+    var input = config._i,
+        format = config._f;
+
+    config._locale = config._locale || getLocale(config._l);
+
+    if (input === null || (format === undefined && input === '')) {
+        return createInvalid({ nullInput: true });
+    }
+
+    if (typeof input === 'string') {
+        config._i = input = config._locale.preparse(input);
+    }
+
+    if (isMoment(input)) {
+        return new Moment(checkOverflow(input));
+    } else if (isDate(input)) {
+        config._d = input;
+    } else if (isArray(format)) {
+        configFromStringAndArray(config);
+    } else if (format) {
+        configFromStringAndFormat(config);
+    } else {
+        configFromInput(config);
+    }
+
+    if (!isValid(config)) {
+        config._d = null;
+    }
+
+    return config;
+}
+
+function configFromInput(config) {
+    var input = config._i;
+    if (isUndefined(input)) {
+        config._d = new Date(hooks.now());
+    } else if (isDate(input)) {
+        config._d = new Date(input.valueOf());
+    } else if (typeof input === 'string') {
+        configFromString(config);
+    } else if (isArray(input)) {
+        config._a = map(input.slice(0), function (obj) {
+            return parseInt(obj, 10);
+        });
+        configFromArray(config);
+    } else if (isObject(input)) {
+        configFromObject(config);
+    } else if (isNumber(input)) {
+        // from milliseconds
+        config._d = new Date(input);
+    } else {
+        hooks.createFromInputFallback(config);
+    }
+}
+
+export function createLocalOrUTC(input, format, locale, strict, isUTC) {
+    var c = {};
+
+    if (format === true || format === false) {
+        strict = format;
+        format = undefined;
+    }
+
+    if (locale === true || locale === false) {
+        strict = locale;
+        locale = undefined;
+    }
+
+    if (
+        (isObject(input) && isObjectEmpty(input)) ||
+        (isArray(input) && input.length === 0)
+    ) {
+        input = undefined;
+    }
+    // object construction must be done this way.
+    // https://github.com/moment/moment/issues/1423
+    c._isAMomentObject = true;
+    c._useUTC = c._isUTC = isUTC;
+    c._l = locale;
+    c._i = input;
+    c._f = format;
+    c._strict = strict;
+
+    return createFromConfig(c);
+}