Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/ignore/README.md b/node_modules/ignore/README.md
new file mode 100644
index 0000000..d8ec079
--- /dev/null
+++ b/node_modules/ignore/README.md
@@ -0,0 +1,262 @@
+<table><thead>
+ <tr>
+ <th>Linux</th>
+ <th>OS X</th>
+ <th>Windows</th>
+ <th>Coverage</th>
+ <th>Downloads</th>
+ </tr>
+</thead><tbody><tr>
+ <td colspan="2" align="center">
+ <a href="https://travis-ci.org/kaelzhang/node-ignore">
+ <img
+ src="https://travis-ci.org/kaelzhang/node-ignore.svg?branch=master"
+ alt="Build Status" /></a>
+ </td>
+ <td align="center">
+ <a href="https://ci.appveyor.com/project/kaelzhang/node-ignore">
+ <img
+ src="https://ci.appveyor.com/api/projects/status/github/kaelzhang/node-ignore?branch=master&svg=true"
+ alt="Windows Build Status" /></a>
+ </td>
+ <td align="center">
+ <a href="https://codecov.io/gh/kaelzhang/node-ignore">
+ <img
+ src="https://codecov.io/gh/kaelzhang/node-ignore/branch/master/graph/badge.svg"
+ alt="Coverage Status" /></a>
+ </td>
+ <td align="center">
+ <a href="https://www.npmjs.org/package/ignore">
+ <img
+ src="http://img.shields.io/npm/dm/ignore.svg"
+ alt="npm module downloads per month" /></a>
+ </td>
+</tr></tbody></table>
+
+# ignore
+
+`ignore` is a manager, filter and parser which implemented in pure JavaScript according to the .gitignore [spec](http://git-scm.com/docs/gitignore).
+
+Pay attention that [`minimatch`](https://www.npmjs.org/package/minimatch) does not work in the gitignore way. To filter filenames according to .gitignore file, I recommend this module.
+
+##### Tested on
+
+- Linux + Node: `0.8` - `7.x`
+- Windows + Node: `0.10` - `7.x`, node < `0.10` is not tested due to the lack of support of appveyor.
+
+Actually, `ignore` does not rely on any versions of node specially.
+
+## Table Of Main Contents
+
+- [Usage](#usage)
+- [Guide for 2.x -> 3.x](#upgrade-2x---3x)
+- [Contributing](#contributing)
+- Related Packages
+ - [`glob-gitignore`](https://www.npmjs.com/package/glob-gitignore) matches files using patterns and filters them according to gitignore rules.
+
+## Usage
+
+```js
+const ignore = require('ignore')
+const ig = ignore().add(['.abc/*', '!.abc/d/'])
+```
+
+### Filter the given paths
+
+```js
+const paths = [
+ '.abc/a.js', // filtered out
+ '.abc/d/e.js' // included
+]
+
+ig.filter(paths) // ['.abc/d/e.js']
+ig.ignores('.abc/a.js') // true
+```
+
+### As the filter function
+
+```js
+paths.filter(ig.createFilter()); // ['.abc/d/e.js']
+```
+
+### Win32 paths will be handled
+
+```js
+ig.filter(['.abc\\a.js', '.abc\\d\\e.js'])
+// if the code above runs on windows, the result will be
+// ['.abc\\d\\e.js']
+```
+
+## Why another ignore?
+
+- `ignore` is a standalone module, and is much simpler so that it could easy work with other programs, unlike [isaacs](https://npmjs.org/~isaacs)'s [fstream-ignore](https://npmjs.org/package/fstream-ignore) which must work with the modules of the fstream family.
+
+- `ignore` only contains utility methods to filter paths according to the specified ignore rules, so
+ - `ignore` never try to find out ignore rules by traversing directories or fetching from git configurations.
+ - `ignore` don't cares about sub-modules of git projects.
+
+- Exactly according to [gitignore man page](http://git-scm.com/docs/gitignore), fixes some known matching issues of fstream-ignore, such as:
+ - '`/*.js`' should only match '`a.js`', but not '`abc/a.js`'.
+ - '`**/foo`' should match '`foo`' anywhere.
+ - Prevent re-including a file if a parent directory of that file is excluded.
+ - Handle trailing whitespaces:
+ - `'a '`(one space) should not match `'a '`(two spaces).
+ - `'a \ '` matches `'a '`
+ - All test cases are verified with the result of `git check-ignore`.
+
+## Methods
+
+### .add(pattern)
+### .add(patterns)
+
+- **pattern** `String|Ignore` An ignore pattern string, or the `Ignore` instance
+- **patterns** `Array.<pattern>` Array of ignore patterns.
+
+Adds a rule or several rules to the current manager.
+
+Returns `this`
+
+Notice that a line starting with `'#'`(hash) is treated as a comment. Put a backslash (`'\'`) in front of the first hash for patterns that begin with a hash, if you want to ignore a file with a hash at the beginning of the filename.
+
+```js
+ignore().add('#abc').ignores('#abc') // false
+ignore().add('\#abc').ignores('#abc') // true
+```
+
+`pattern` could either be a line of ignore pattern or a string of multiple ignore patterns, which means we could just `ignore().add()` the content of a ignore file:
+
+```js
+ignore()
+.add(fs.readFileSync(filenameOfGitignore).toString())
+.filter(filenames)
+```
+
+`pattern` could also be an `ignore` instance, so that we could easily inherit the rules of another `Ignore` instance.
+
+### <strike>.addIgnoreFile(path)</strike>
+
+REMOVED in `3.x` for now.
+
+To upgrade `ignore@2.x` up to `3.x`, use
+
+```js
+const fs = require('fs')
+
+if (fs.existsSync(filename)) {
+ ignore().add(fs.readFileSync(filename).toString())
+}
+```
+
+instead.
+
+
+### .ignores(pathname)
+
+> new in 3.2.0
+
+Returns `Boolean` whether `pathname` should be ignored.
+
+```js
+ig.ignores('.abc/a.js') // true
+```
+
+### .filter(paths)
+
+Filters the given array of pathnames, and returns the filtered array.
+
+- **paths** `Array.<path>` The array of `pathname`s to be filtered.
+
+**NOTICE** that:
+
+- `pathname` should be a string that have been `path.join()`ed, or the return value of `path.relative()` to the current directory.
+
+```js
+// WRONG
+ig.ignores('./abc')
+
+// WRONG, for it will never happen.
+// If the gitignore rule locates at the root directory,
+// `'/abc'` should be changed to `'abc'`.
+// ```
+// path.relative('/', '/abc') -> 'abc'
+// ```
+ig.ignores('/abc')
+
+// Right
+ig.ignores('abc')
+
+// Right
+ig.ignores(path.join('./abc')) // path.join('./abc') -> 'abc'
+```
+
+- In other words, each `pathname` here should be a relative path to the directory of the git ignore rules.
+
+Suppose the dir structure is:
+
+```
+/path/to/your/repo
+ |-- a
+ | |-- a.js
+ |
+ |-- .b
+ |
+ |-- .c
+ |-- .DS_store
+```
+
+Then the `paths` might be like this:
+
+```js
+[
+ 'a/a.js'
+ '.b',
+ '.c/.DS_store'
+]
+```
+
+Usually, you could use [`glob`](http://npmjs.org/package/glob) with `option.mark = true` to fetch the structure of the current directory:
+
+```js
+const glob = require('glob')
+
+glob('**', {
+ // Adds a / character to directory matches.
+ mark: true
+}, (err, files) => {
+ if (err) {
+ return console.error(err)
+ }
+
+ let filtered = ignore().add(patterns).filter(files)
+ console.log(filtered)
+})
+```
+
+### .createFilter()
+
+Creates a filter function which could filter an array of paths with `Array.prototype.filter`.
+
+Returns `function(path)` the filter function.
+
+****
+
+## Upgrade 2.x -> 3.x
+
+- All `options` of 2.x are unnecessary and removed, so just remove them.
+- `ignore()` instance is no longer an [`EventEmitter`](nodejs.org/api/events.html), and all events are unnecessary and removed.
+- `.addIgnoreFile()` is removed, see the [.addIgnoreFile](#addignorefilepath) section for details.
+
+****
+
+## Contributing
+
+The code of `node-ignore` is based on es6 and babel, but babel and its preset is not included in the `dependencies` field of package.json, so that the installation process of test cases will not fail in older versions of node.
+
+So use `bash install.sh` to install dependencies and `bash test.sh` to run test cases in your local machine.
+
+#### Collaborators
+
+- [SamyPesse](https://github.com/SamyPesse) *Samy Pessé*
+- [azproduction](https://github.com/azproduction) *Mikhail Davydov*
+- [TrySound](https://github.com/TrySound) *Bogdan Chadkin*
+- [JanMattner](https://github.com/JanMattner) *Jan Mattner*
diff --git a/node_modules/ignore/ignore.js b/node_modules/ignore/ignore.js
new file mode 100644
index 0000000..111fceb
--- /dev/null
+++ b/node_modules/ignore/ignore.js
@@ -0,0 +1,425 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+module.exports = function () {
+ return new IgnoreBase();
+};
+
+// A simple implementation of make-array
+function make_array(subject) {
+ return Array.isArray(subject) ? subject : [subject];
+}
+
+var REGEX_BLANK_LINE = /^\s+$/;
+var REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\\!/;
+var REGEX_LEADING_EXCAPED_HASH = /^\\#/;
+var SLASH = '/';
+var KEY_IGNORE = typeof Symbol !== 'undefined' ? Symbol.for('node-ignore')
+/* istanbul ignore next */
+: 'node-ignore';
+
+var IgnoreBase = function () {
+ function IgnoreBase() {
+ _classCallCheck(this, IgnoreBase);
+
+ this._rules = [];
+ this[KEY_IGNORE] = true;
+ this._initCache();
+ }
+
+ _createClass(IgnoreBase, [{
+ key: '_initCache',
+ value: function _initCache() {
+ this._cache = {};
+ }
+
+ // @param {Array.<string>|string|Ignore} pattern
+
+ }, {
+ key: 'add',
+ value: function add(pattern) {
+ this._added = false;
+
+ if (typeof pattern === 'string') {
+ pattern = pattern.split(/\r?\n/g);
+ }
+
+ make_array(pattern).forEach(this._addPattern, this);
+
+ // Some rules have just added to the ignore,
+ // making the behavior changed.
+ if (this._added) {
+ this._initCache();
+ }
+
+ return this;
+ }
+
+ // legacy
+
+ }, {
+ key: 'addPattern',
+ value: function addPattern(pattern) {
+ return this.add(pattern);
+ }
+ }, {
+ key: '_addPattern',
+ value: function _addPattern(pattern) {
+ // #32
+ if (pattern && pattern[KEY_IGNORE]) {
+ this._rules = this._rules.concat(pattern._rules);
+ this._added = true;
+ return;
+ }
+
+ if (this._checkPattern(pattern)) {
+ var rule = this._createRule(pattern);
+ this._added = true;
+ this._rules.push(rule);
+ }
+ }
+ }, {
+ key: '_checkPattern',
+ value: function _checkPattern(pattern) {
+ // > A blank line matches no files, so it can serve as a separator for readability.
+ return pattern && typeof pattern === 'string' && !REGEX_BLANK_LINE.test(pattern)
+
+ // > A line starting with # serves as a comment.
+ && pattern.indexOf('#') !== 0;
+ }
+ }, {
+ key: 'filter',
+ value: function filter(paths) {
+ var _this = this;
+
+ return make_array(paths).filter(function (path) {
+ return _this._filter(path);
+ });
+ }
+ }, {
+ key: 'createFilter',
+ value: function createFilter() {
+ var _this2 = this;
+
+ return function (path) {
+ return _this2._filter(path);
+ };
+ }
+ }, {
+ key: 'ignores',
+ value: function ignores(path) {
+ return !this._filter(path);
+ }
+ }, {
+ key: '_createRule',
+ value: function _createRule(pattern) {
+ var origin = pattern;
+ var negative = false;
+
+ // > An optional prefix "!" which negates the pattern;
+ if (pattern.indexOf('!') === 0) {
+ negative = true;
+ pattern = pattern.substr(1);
+ }
+
+ pattern = pattern
+ // > Put a backslash ("\") in front of the first "!" for patterns that begin with a literal "!", for example, `"\!important!.txt"`.
+ .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!')
+ // > Put a backslash ("\") in front of the first hash for patterns that begin with a hash.
+ .replace(REGEX_LEADING_EXCAPED_HASH, '#');
+
+ var regex = make_regex(pattern, negative);
+
+ return {
+ origin: origin,
+ pattern: pattern,
+ negative: negative,
+ regex: regex
+ };
+ }
+
+ // @returns `Boolean` true if the `path` is NOT ignored
+
+ }, {
+ key: '_filter',
+ value: function _filter(path, slices) {
+ if (!path) {
+ return false;
+ }
+
+ if (path in this._cache) {
+ return this._cache[path];
+ }
+
+ if (!slices) {
+ // path/to/a.js
+ // ['path', 'to', 'a.js']
+ slices = path.split(SLASH);
+ }
+
+ slices.pop();
+
+ return this._cache[path] = slices.length
+ // > It is not possible to re-include a file if a parent directory of that file is excluded.
+ // If the path contains a parent directory, check the parent first
+ ? this._filter(slices.join(SLASH) + SLASH, slices) && this._test(path)
+
+ // Or only test the path
+ : this._test(path);
+ }
+
+ // @returns {Boolean} true if a file is NOT ignored
+
+ }, {
+ key: '_test',
+ value: function _test(path) {
+ // Explicitly define variable type by setting matched to `0`
+ var matched = 0;
+
+ this._rules.forEach(function (rule) {
+ // if matched = true, then we only test negative rules
+ // if matched = false, then we test non-negative rules
+ if (!(matched ^ rule.negative)) {
+ matched = rule.negative ^ rule.regex.test(path);
+ }
+ });
+
+ return !matched;
+ }
+ }]);
+
+ return IgnoreBase;
+}();
+
+// > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// > (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+// you could use option `mark: true` with `glob`
+
+// '`foo/`' should not continue with the '`..`'
+
+
+var DEFAULT_REPLACER_PREFIX = [
+
+// > Trailing spaces are ignored unless they are quoted with backslash ("\")
+[
+// (a\ ) -> (a )
+// (a ) -> (a)
+// (a \ ) -> (a )
+/\\?\s+$/, function (match) {
+ return match.indexOf('\\') === 0 ? ' ' : '';
+}],
+
+// replace (\ ) with ' '
+[/\\\s/g, function () {
+ return ' ';
+}],
+
+// Escape metacharacters
+// which is written down by users but means special for regular expressions.
+
+// > There are 12 characters with special meanings:
+// > - the backslash \,
+// > - the caret ^,
+// > - the dollar sign $,
+// > - the period or dot .,
+// > - the vertical bar or pipe symbol |,
+// > - the question mark ?,
+// > - the asterisk or star *,
+// > - the plus sign +,
+// > - the opening parenthesis (,
+// > - the closing parenthesis ),
+// > - and the opening square bracket [,
+// > - the opening curly brace {,
+// > These special characters are often called "metacharacters".
+[/[\\\^$.|?*+()\[{]/g, function (match) {
+ return '\\' + match;
+}],
+
+// leading slash
+[
+
+// > A leading slash matches the beginning of the pathname.
+// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+// A leading slash matches the beginning of the pathname
+/^\//, function () {
+ return '^';
+}],
+
+// replace special metacharacter slash after the leading slash
+[/\//g, function () {
+ return '\\/';
+}], [
+// > A leading "**" followed by a slash means match in all directories.
+// > For example, "**/foo" matches file or directory "foo" anywhere,
+// > the same as pattern "foo".
+// > "**/foo/bar" matches file or directory "bar" anywhere that is directly under directory "foo".
+// Notice that the '*'s have been replaced as '\\*'
+/^\^*\\\*\\\*\\\//,
+
+// '**/foo' <-> 'foo'
+function () {
+ return '^(?:.*\\/)?';
+}]];
+
+var DEFAULT_REPLACER_SUFFIX = [
+// starting
+[
+// there will be no leading '/' (which has been replaced by section "leading slash")
+// If starts with '**', adding a '^' to the regular expression also works
+/^(?=[^\^])/, function () {
+ return !/\/(?!$)/.test(this)
+ // > If the pattern does not contain a slash /, Git treats it as a shell glob pattern
+ // Actually, if there is only a trailing slash, git also treats it as a shell glob pattern
+ ? '(?:^|\\/)'
+
+ // > Otherwise, Git treats the pattern as a shell glob suitable for consumption by fnmatch(3)
+ : '^';
+}],
+
+// two globstars
+[
+// Use lookahead assertions so that we could match more than one `'/**'`
+/\\\/\\\*\\\*(?=\\\/|$)/g,
+
+// Zero, one or several directories
+// should not use '*', or it will be replaced by the next replacer
+
+// Check if it is not the last `'/**'`
+function (match, index, str) {
+ return index + 6 < str.length
+
+ // case: /**/
+ // > A slash followed by two consecutive asterisks then a slash matches zero or more directories.
+ // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+ // '/**/'
+ ? '(?:\\/[^\\/]+)*'
+
+ // case: /**
+ // > A trailing `"/**"` matches everything inside.
+
+ // #21: everything inside but it should not include the current folder
+ : '\\/.+';
+}],
+
+// intermediate wildcards
+[
+// Never replace escaped '*'
+// ignore rule '\*' will match the path '*'
+
+// 'abc.*/' -> go
+// 'abc.*' -> skip this rule
+/(^|[^\\]+)\\\*(?=.+)/g,
+
+// '*.js' matches '.js'
+// '*.js' doesn't match 'abc'
+function (match, p1) {
+ return p1 + '[^\\/]*';
+}],
+
+// trailing wildcard
+[/(\^|\\\/)?\\\*$/, function (match, p1) {
+ return (p1
+ // '\^':
+ // '/*' does not match ''
+ // '/*' does not match everything
+
+ // '\\\/':
+ // 'abc/*' does not match 'abc/'
+ ? p1 + '[^/]+'
+
+ // 'a*' matches 'a'
+ // 'a*' matches 'aa'
+ : '[^/]*') + '(?=$|\\/$)';
+}], [
+// unescape
+/\\\\\\/g, function () {
+ return '\\';
+}]];
+
+var POSITIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [
+
+// 'f'
+// matches
+// - /f(end)
+// - /f/
+// - (start)f(end)
+// - (start)f/
+// doesn't match
+// - oof
+// - foo
+// pseudo:
+// -> (^|/)f(/|$)
+
+// ending
+[
+// 'js' will not match 'js.'
+// 'ab' will not match 'abc'
+/(?:[^*\/])$/,
+
+// 'js*' will not match 'a.js'
+// 'js/' will not match 'a.js'
+// 'js' will match 'a.js' and 'a.js/'
+function (match) {
+ return match + '(?=$|\\/)';
+}]], DEFAULT_REPLACER_SUFFIX);
+
+var NEGATIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [
+
+// #24, #38
+// The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)
+// A negative pattern without a trailing wildcard should not
+// re-include the things inside that directory.
+
+// eg:
+// ['node_modules/*', '!node_modules']
+// should ignore `node_modules/a.js`
+[/(?:[^*])$/, function (match) {
+ return match + '(?=$|\\/$)';
+}]], DEFAULT_REPLACER_SUFFIX);
+
+// A simple cache, because an ignore rule only has only one certain meaning
+var cache = {};
+
+// @param {pattern}
+function make_regex(pattern, negative) {
+ var r = cache[pattern];
+ if (r) {
+ return r;
+ }
+
+ var replacers = negative ? NEGATIVE_REPLACERS : POSITIVE_REPLACERS;
+
+ var source = replacers.reduce(function (prev, current) {
+ return prev.replace(current[0], current[1].bind(pattern));
+ }, pattern);
+
+ return cache[pattern] = new RegExp(source, 'i');
+}
+
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore if */
+if (
+// Detect `process` so that it can run in browsers.
+typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) {
+
+ var filter = IgnoreBase.prototype._filter;
+ var make_posix = function make_posix(str) {
+ return (/^\\\\\?\\/.test(str) || /[^\x00-\x80]+/.test(str) ? str : str.replace(/\\/g, '/')
+ );
+ };
+
+ IgnoreBase.prototype._filter = function (path, slices) {
+ path = make_posix(path);
+ return filter.call(this, path, slices);
+ };
+}
diff --git a/node_modules/ignore/index.d.ts b/node_modules/ignore/index.d.ts
new file mode 100644
index 0000000..fab7d48
--- /dev/null
+++ b/node_modules/ignore/index.d.ts
@@ -0,0 +1,41 @@
+interface Ignore {
+ /**
+ * Adds a rule rules to the current manager.
+ * @param {string | Ignore} pattern
+ * @returns IgnoreBase
+ */
+ add(pattern: string | Ignore): Ignore
+ /**
+ * Adds several rules to the current manager.
+ * @param {string[]} patterns
+ * @returns IgnoreBase
+ */
+ add(patterns: (string | Ignore)[]): Ignore
+
+ /**
+ * Filters the given array of pathnames, and returns the filtered array.
+ * NOTICE that each path here should be a relative path to the root of your repository.
+ * @param paths the array of paths to be filtered.
+ * @returns The filtered array of paths
+ */
+ filter(paths: string[]): string[]
+ /**
+ * Creates a filter function which could filter
+ * an array of paths with Array.prototype.filter.
+ */
+ createFilter(): (path: string) => boolean
+
+ /**
+ * Returns Boolean whether pathname should be ignored.
+ * @param {string} pathname a path to check
+ * @returns boolean
+ */
+ ignores(pathname: string): boolean
+}
+
+/**
+ * Creates new ignore manager.
+ */
+declare function ignore(): Ignore
+
+export default ignore
diff --git a/node_modules/ignore/package.json b/node_modules/ignore/package.json
new file mode 100644
index 0000000..02f9426
--- /dev/null
+++ b/node_modules/ignore/package.json
@@ -0,0 +1,84 @@
+{
+ "_from": "ignore@^3.3.5",
+ "_id": "ignore@3.3.10",
+ "_inBundle": false,
+ "_integrity": "sha512-Pgs951kaMm5GXP7MOvxERINe3gsaVjUWFm+UZPSq9xYriQAksyhg0csnS0KXSNRD5NmNdapXEpjxG49+AKh/ug==",
+ "_location": "/ignore",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "ignore@^3.3.5",
+ "name": "ignore",
+ "escapedName": "ignore",
+ "rawSpec": "^3.3.5",
+ "saveSpec": null,
+ "fetchSpec": "^3.3.5"
+ },
+ "_requiredBy": [
+ "/globby"
+ ],
+ "_resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.10.tgz",
+ "_shasum": "0a97fb876986e8081c631160f8f9f389157f0043",
+ "_spec": "ignore@^3.3.5",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\globby",
+ "author": {
+ "name": "kael"
+ },
+ "bugs": {
+ "url": "https://github.com/kaelzhang/node-ignore/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Ignore is a manager and filter for .gitignore rules.",
+ "devDependencies": {
+ "babel-cli": "^6.26.0",
+ "babel-preset-es2015": "^6.24.1",
+ "chai": "~1.7.2",
+ "codecov": "^3.0.2",
+ "istanbul": "^0.4.5",
+ "mkdirp": "^0.5.1",
+ "mocha": "~1.13.0",
+ "pre-suf": "^1.0.4",
+ "rimraf": "^2.6.2",
+ "spawn-sync": "^1.0.15",
+ "tmp": "0.0.33",
+ "typescript": "^2.9.2"
+ },
+ "files": [
+ "ignore.js",
+ "index.d.ts"
+ ],
+ "homepage": "https://github.com/kaelzhang/node-ignore#readme",
+ "keywords": [
+ "ignore",
+ ".gitignore",
+ "gitignore",
+ "npmignore",
+ "rules",
+ "manager",
+ "filter",
+ "regexp",
+ "regex",
+ "fnmatch",
+ "glob",
+ "asterisks",
+ "regular-expression"
+ ],
+ "license": "MIT",
+ "main": "./ignore.js",
+ "name": "ignore",
+ "repository": {
+ "type": "git",
+ "url": "git+ssh://git@github.com/kaelzhang/node-ignore.git"
+ },
+ "scripts": {
+ "build": "babel -o ignore.js index.js",
+ "cov-report": "istanbul report",
+ "prepublish": "npm run build",
+ "test": "npm run tsc && npm run build && istanbul cover ./node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec ./test/ignore.js && codecov",
+ "test-no-cov": "npm run tsc && npm run build && mocha --reporter spec ./test/ignore.js",
+ "tsc": "tsc ./test/ts/simple.ts"
+ },
+ "version": "3.3.10"
+}