update

node_modules/editorconfig/CHANGELOG.md

@@ -0,0 +1,14 @@
+## 0.15.3
+- Move @types dependencies to dev dependencies.
+- Upgrade dependencies.
+
+## 0.15.2
+- Fix publish.
+
+## 0.15.1
+- Update dependencies.
+
+## 0.15.0
+- Convert source code into TypeScript. Generated type definitions are now provided.
+- Remove dependency on Bluebird.
+- **Breaking**: Node v4 no longer supported.

node_modules/editorconfig/LICENSE

@@ -0,0 +1,19 @@
+Copyright © 2012 EditorConfig Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/editorconfig/README.md

@@ -0,0 +1,206 @@
+# EditorConfig JavaScript Core
+
+[![Build Status](https://travis-ci.org/editorconfig/editorconfig-core-js.svg?branch=master)](https://travis-ci.org/editorconfig/editorconfig-core-js)
+[![dependencies Status](https://david-dm.org/editorconfig/editorconfig-core-js/status.svg)](https://david-dm.org/editorconfig/editorconfig-core-js)
+
+The EditorConfig JavaScript core will provide the same functionality as the
+[EditorConfig C Core][] and [EditorConfig Python Core][].
+
+
+## Installation
+
+You need [node][] to use this package.
+
+To install the package locally:
+
+```bash
+$ npm install editorconfig
+```
+
+To install the package system-wide:
+
+```bash
+$ npm install -g editorconfig
+```
+
+## Usage
+
+### in Node.js:
+
+#### parse(filePath[, options])
+
+options is an object with the following defaults:
+
+```js
+{
+  config: '.editorconfig',
+  version: pkg.version,
+  root: '/'
+};
+```
+
+Search for `.editorconfig` starting from the current directory to the root directory.
+
+Example:
+
+```js
+var editorconfig = require('editorconfig');
+var path = require('path');
+var filePath = path.join(__dirname, '/sample.js');
+var promise = editorconfig.parse(filePath);
+promise.then(function onFulfilled(result) {
+  console.log(result);
+});
+
+/*
+  {
+    indent_style: 'space',
+    indent_size: 2,
+    end_of_line: 'lf',
+    charset: 'utf-8',
+    trim_trailing_whitespace: true,
+    insert_final_newline: true,
+    tab_width: 2
+  };
+*/
+```
+
+#### parseSync(filePath[, options])
+
+Synchronous version of `editorconfig.parse()`.
+
+#### parseString(fileContent)
+
+The `parse()` function above uses `parseString()` under the hood. If you have your file contents
+just pass it to `parseString()` and it'll return the same results as `parse()`.
+
+#### parseFromFiles(filePath, configs[, options])
+
+options is an object with the following defaults:
+
+```js
+{
+  config: '.editorconfig',
+  version: pkg.version,
+  root: '/'
+};
+```
+
+Specify the `.editorconfig`.
+
+Example:
+
+```js
+var editorconfig = require('editorconfig');
+var fs = require('fs');
+var path = require('path');
+var configPath = path.join(__dirname, '/.editorconfig');
+var configs = [
+  {
+    name: configPath,
+    contents: fs.readFileSync(configPath, 'utf8')
+  }
+];
+var filePath = path.join(__dirname, '/sample.js');
+var promise = editorconfig.parseFromFiles(filePath, configs);
+promise.then(function onFulfilled(result) {
+  console.log(result)
+});
+
+/*
+  {
+    indent_style: 'space',
+    indent_size: 2,
+    end_of_line: 'lf',
+    charset: 'utf-8',
+    trim_trailing_whitespace: true,
+    insert_final_newline: true,
+    tab_width: 2
+  };
+*/
+```
+
+#### parseFromFilesSync(filePath, configs[, options])
+
+Synchronous version of `editorconfig.parseFromFiles()`.
+
+### in Command Line
+
+```bash
+$ ./bin/editorconfig
+
+    Usage: editorconfig [OPTIONS] FILEPATH1 [FILEPATH2 FILEPATH3 ...]
+
+    EditorConfig Node.js Core Version 0.11.4-development
+
+    FILEPATH can be a hyphen (-) if you want path(s) to be read from stdin.
+
+    Options:
+
+        -h, --help     output usage information
+        -V, --version  output the version number
+        -f <path>      Specify conf filename other than ".editorconfig"
+        -b <version>   Specify version (used by devs to test compatibility)
+```
+
+Example:
+
+```bash
+$ ./bin/editorconfig /home/zoidberg/humans/anatomy.md
+charset=utf-8
+insert_final_newline=true
+end_of_line=lf
+tab_width=8
+trim_trailing_whitespace=sometimes
+```
+
+## Development
+
+To install dependencies for this package run this in the package directory:
+
+```bash
+$ npm install
+```
+
+Next, run the following commands:
+
+```bash
+$ npm run build
+$ npm run copy
+$ npm link ./dist
+```
+
+The global editorconfig will now point to the files in your development
+repository instead of a globally-installed version from npm. You can now use
+editorconfig directly to test your changes.
+
+If you ever update from the central repository and there are errors, it might
+be because you are missing some dependencies. If that happens, just run npm
+link again to get the latest dependencies.
+
+To test the command line interface:
+
+```bash
+$ editorconfig <filepath>
+```
+
+# Testing
+
+[CMake][] must be installed to run the tests.
+
+To run the tests:
+
+```bash
+$ npm test
+```
+
+To run the tests with increased verbosity (for debugging test failures):
+
+```bash
+$ npm run-script test-verbose
+```
+
+[EditorConfig C Core]: https://github.com/editorconfig/editorconfig-core
+[EditorConfig Python Core]: https://github.com/editorconfig/editorconfig-core-py
+[node]: http://nodejs.org/
+[cmake]: http://www.cmake.org

node_modules/editorconfig/bin/editorconfig

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+var cli = require('../src/cli')
+cli.default(process.argv)

node_modules/editorconfig/node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver

node_modules/editorconfig/node_modules/semver/CHANGELOG.md

@@ -0,0 +1,39 @@
+# changes log
+
+## 5.7
+
+* Add `minVersion` method
+
+## 5.6
+
+* Move boolean `loose` param to an options object, with
+  backwards-compatibility protection.
+* Add ability to opt out of special prerelease version handling with
+  the `includePrerelease` option flag.
+
+## 5.5
+
+* Add version coercion capabilities
+
+## 5.4
+
+* Add intersection checking
+
+## 5.3
+
+* Add `minSatisfying` method
+
+## 5.2
+
+* Add `prerelease(v)` that returns prerelease components
+
+## 5.1
+
+* Add Backus-Naur for ranges
+* Remove excessively cute inspection methods
+
+## 5.0
+
+* Remove AMD/Browserified build artifacts
+* Fix ltr and gtr when using the `*` range
+* Fix for range `*` with a prerelease identifier

node_modules/editorconfig/node_modules/semver/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/editorconfig/node_modules/semver/README.md

@@ -0,0 +1,412 @@
+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Install
+
+```bash
+npm install --save semver
+````
+
+## Usage
+
+As a node module:
+
+```js
+const semver = require('semver')
+
+semver.valid('1.2.3') // '1.2.3'
+semver.valid('a.b.c') // null
+semver.clean('  =v1.2.3   ') // '1.2.3'
+semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+semver.gt('1.2.3', '9.8.7') // false
+semver.lt('1.2.3', '9.8.7') // true
+semver.minVersion('>=1.0.0') // '1.0.0'
+semver.valid(semver.coerce('v2')) // '2.0.0'
+semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
+```
+
+As a command-line utility:
+
+```
+$ semver -h
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.
+```
+
+## Versions
+
+A "version" is described by the `v2.0.0` specification found at
+<https://semver.org/>.
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+
+## Ranges
+
+A `version range` is a set of `comparators` which specify versions
+that satisfy the range.
+
+A `comparator` is composed of an `operator` and a `version`.  The set
+of primitive `operators` is:
+
+* `<` Less than
+* `<=` Less than or equal to
+* `>` Greater than
+* `>=` Greater than or equal to
+* `=` Equal.  If no operator is specified, then equality is assumed,
+  so this operator is optional, but MAY be included.
+
+For example, the comparator `>=1.2.7` would match the versions
+`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
+or `1.1.0`.
+
+Comparators can be joined by whitespace to form a `comparator set`,
+which is satisfied by the **intersection** of all of the comparators
+it includes.
+
+A range is composed of one or more comparator sets, joined by `||`.  A
+version matches a range if and only if every comparator in at least
+one of the `||`-separated comparator sets is satisfied by the version.
+
+For example, the range `>=1.2.7 <1.3.0` would match the versions
+`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
+or `1.1.0`.
+
+The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
+`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+
+### Prerelease Tags
+
+If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
+it will only be allowed to satisfy comparator sets if at least one
+comparator with the same `[major, minor, patch]` tuple also has a
+prerelease tag.
+
+For example, the range `>1.2.3-alpha.3` would be allowed to match the
+version `1.2.3-alpha.7`, but it would *not* be satisfied by
+`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
+than" `1.2.3-alpha.3` according to the SemVer sort rules.  The version
+range only accepts prerelease tags on the `1.2.3` version.  The
+version `3.4.5` *would* satisfy the range, because it does not have a
+prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+
+The purpose for this behavior is twofold.  First, prerelease versions
+frequently are updated very quickly, and contain many breaking changes
+that are (by the author's design) not yet fit for public consumption.
+Therefore, by default, they are excluded from range matching
+semantics.
+
+Second, a user who has opted into using a prerelease version has
+clearly indicated the intent to use *that specific* set of
+alpha/beta/rc versions.  By including a prerelease tag in the range,
+the user is indicating that they are aware of the risk.  However, it
+is still not appropriate to assume that they have opted into taking a
+similar risk on the *next* set of prerelease versions.
+
+Note that this behavior can be suppressed (treating all prerelease
+versions as if they were normal versions, for the purpose of range
+matching) by setting the `includePrerelease` flag on the options
+object to any
+[functions](https://github.com/npm/node-semver#functions) that do
+range matching.
+
+#### Prerelease Identifiers
+
+The method `.inc` takes an additional `identifier` string argument that
+will append the value of the string as a prerelease identifier:
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta')
+// '1.2.4-beta.0'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta
+1.2.4-beta.0
+```
+
+Which then can be used to increment further:
+
+```bash
+$ semver 1.2.4-beta.0 -i prerelease
+1.2.4-beta.1
+```
+
+### Advanced Range Syntax
+
+Advanced range syntax desugars to primitive comparators in
+deterministic ways.
+
+Advanced ranges may be combined in the same way as primitive
+comparators using white space or `||`.
+
+#### Hyphen Ranges `X.Y.Z - A.B.C`
+
+Specifies an inclusive set.
+
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+
+If a partial version is provided as the first version in the inclusive
+range, then the missing pieces are replaced with zeroes.
+
+* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+
+If a partial version is provided as the second version in the
+inclusive range, then all versions that start with the supplied parts
+of the tuple are accepted, but nothing that would be greater than the
+provided tuple parts.
+
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0`
+
+#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+
+Any of `X`, `x`, or `*` may be used to "stand in" for one of the
+numeric values in the `[major, minor, patch]` tuple.
+
+* `*` := `>=0.0.0` (Any version satisfies)
+* `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
+
+A partial version range is treated as an X-Range, so the special
+character is in fact optional.
+
+* `""` (empty string) := `*` := `>=0.0.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
+
+#### Tilde Ranges `~1.2.3` `~1.2` `~1`
+
+Allows patch-level changes if a minor version is specified on the
+comparator.  Allows minor-level changes if not.
+
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+
+#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+
+Allows changes that do not modify the left-most non-zero digit in the
+`[major, minor, patch]` tuple.  In other words, this allows patch and
+minor updates for versions `1.0.0` and above, patch updates for
+versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
+
+Many authors treat a `0.x` version as if the `x` were the major
+"breaking-change" indicator.
+
+Caret ranges are ideal when an author may make breaking changes
+between `0.2.4` and `0.3.0` releases, which is a common practice.
+However, it presumes that there will *not* be breaking changes between
+`0.2.4` and `0.2.5`.  It allows for changes that are presumed to be
+additive (but non-breaking), according to commonly observed practices.
+
+* `^1.2.3` := `>=1.2.3 <2.0.0`
+* `^0.2.3` := `>=0.2.3 <0.3.0`
+* `^0.0.3` := `>=0.0.3 <0.0.4`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4`  Note that prereleases in the
+  `0.0.3` version *only* will be allowed, if they are greater than or
+  equal to `beta`.  So, `0.0.3-pr.2` would be allowed.
+
+When parsing caret ranges, a missing `patch` value desugars to the
+number `0`, but will allow flexibility within that value, even if the
+major and minor versions are both `0`.
+
+* `^1.2.x` := `>=1.2.0 <2.0.0`
+* `^0.0.x` := `>=0.0.0 <0.1.0`
+* `^0.0` := `>=0.0.0 <0.1.0`
+
+A missing `minor` and `patch` values will desugar to zero, but also
+allow flexibility within those values, even if the major version is
+zero.
+
+* `^1.x` := `>=1.0.0 <2.0.0`
+* `^0.x` := `>=0.0.0 <1.0.0`
+
+### Range Grammar
+
+Putting all this together, here is a Backus-Naur grammar for ranges,
+for the benefit of parser authors:
+
+```bnf
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+
+```
+
+## Functions
+
+All methods and classes take a final `options` object argument.  All
+options in this object are `false` by default.  The options supported
+are:
+
+- `loose`  Be more forgiving about not-quite-valid semver strings.
+  (Any resulting output will always be 100% strict compliant, of
+  course.)  For backwards compatibility reasons, if the `options`
+  argument is a boolean value instead of an object, it is interpreted
+  to be the `loose` param.
+- `includePrerelease`  Set to suppress the [default
+  behavior](https://github.com/npm/node-semver#prerelease-tags) of
+  excluding prerelease tagged versions from ranges unless they are
+  explicitly opted into.
+
+Strict-mode Comparators and Ranges will be strict about the SemVer
+strings that they parse.
+
+* `valid(v)`: Return the parsed version, or null if it's not valid.
+* `inc(v, release)`: Return the version incremented by the release
+  type (`major`,   `premajor`, `minor`, `preminor`, `patch`,
+  `prepatch`, or `prerelease`), or null if it's not valid
+  * `premajor` in one call will bump the version up to the next major
+    version and down to a prerelease of that major version.
+    `preminor`, and `prepatch` work the same way.
+  * If called from a non-prerelease version, the `prerelease` will work the
+    same as `prepatch`. It increments the patch version, then makes a
+    prerelease. If the input version is already a prerelease it simply
+    increments it.
+* `prerelease(v)`: Returns an array of prerelease components, or null
+  if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
+* `major(v)`: Return the major version number.
+* `minor(v)`: Return the minor version number.
+* `patch(v)`: Return the patch version number.
+* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
+  or comparators intersect.
+* `parse(v)`: Attempt to parse a string as a semantic version, returning either
+  a `SemVer` object or `null`.
+
+### Comparison
+
+* `gt(v1, v2)`: `v1 > v2`
+* `gte(v1, v2)`: `v1 >= v2`
+* `lt(v1, v2)`: `v1 < v2`
+* `lte(v1, v2)`: `v1 <= v2`
+* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
+  even if they're not the exact same string.  You already know how to
+  compare strings.
+* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
+* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
+  the corresponding function above.  `"==="` and `"!=="` do simple
+  string comparison, but are included for completeness.  Throws if an
+  invalid comparison string is provided.
+* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `rcompare(v1, v2)`: The reverse of compare.  Sorts an array of versions
+  in descending order when passed to `Array.sort()`.
+* `diff(v1, v2)`: Returns difference between two versions by the release type
+  (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
+  or null if the versions are the same.
+
+### Comparators
+
+* `intersects(comparator)`: Return true if the comparators intersect
+
+### Ranges
+
+* `validRange(range)`: Return the valid range or null if it's not valid
+* `satisfies(version, range)`: Return true if the version satisfies the
+  range.
+* `maxSatisfying(versions, range)`: Return the highest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minSatisfying(versions, range)`: Return the lowest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minVersion(range)`: Return the lowest version that can possibly match
+  the given range.
+* `gtr(version, range)`: Return `true` if version is greater than all the
+  versions possible in the range.
+* `ltr(version, range)`: Return `true` if version is less than all the
+  versions possible in the range.
+* `outside(version, range, hilo)`: Return true if the version is outside
+  the bounds of the range in either the high or low direction.  The
+  `hilo` argument must be either the string `'>'` or `'<'`.  (This is
+  the function called by `gtr` and `ltr`.)
+* `intersects(range)`: Return true if any of the ranges comparators intersect
+
+Note that, since ranges may be non-contiguous, a version might not be
+greater than a range, less than a range, *or* satisfy a range!  For
+example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
+until `2.0.0`, so the version `1.2.10` would not be greater than the
+range (because `2.0.1` satisfies, which is higher), nor less than the
+range (since `1.2.8` satisfies, which is lower), and it also does not
+satisfy the range.
+
+If you want to know if a version satisfies or does not satisfy a
+range, use the `satisfies(version, range)` function.
+
+### Coercion
+
+* `coerce(version)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string, and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`).  Only text which lacks digits will fail coercion (`version one`
+is not valid).  The maximum  length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any
+semver component is `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).

node_modules/editorconfig/node_modules/semver/bin/semver

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+var argv = process.argv.slice(2)
+
+var versions = []
+
+var range = []
+
+var inc = null
+
+var version = require('../package.json').version
+
+var loose = false
+
+var includePrerelease = false
+
+var coerce = false
+
+var identifier
+
+var semver = require('../semver')
+
+var reverse = false
+
+var options = {}
+
+main()
+
+function main () {
+  if (!argv.length) return help()
+  while (argv.length) {
+    var a = argv.shift()
+    var indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(a.slice(indexOfEqualSign + 1))
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  var options = { loose: loose, includePrerelease: includePrerelease }
+
+  versions = versions.map(function (v) {
+    return coerce ? (semver.coerce(v) || { version: v }).version : v
+  }).filter(function (v) {
+    return semver.valid(v)
+  })
+  if (!versions.length) return fail()
+  if (inc && (versions.length !== 1 || range.length)) { return failInc() }
+
+  for (var i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter(function (v) {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) return fail()
+  }
+  return success(versions)
+}
+
+function failInc () {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+function fail () { process.exit(1) }
+
+function success () {
+  var compare = reverse ? 'rcompare' : 'compare'
+  versions.sort(function (a, b) {
+    return semver[compare](a, b, options)
+  }).map(function (v) {
+    return semver.clean(v, options)
+  }).map(function (v) {
+    return inc ? semver.inc(v, inc, options, identifier) : v
+  }).forEach(function (v, i, _) { console.log(v) })
+}
+
+function help () {
+  console.log(['SemVer ' + version,
+    '',
+    'A JavaScript implementation of the https://semver.org/ specification',
+    'Copyright Isaac Z. Schlueter',
+    '',
+    'Usage: semver [options] <version> [<version> [...]]',
+    'Prints valid versions sorted by SemVer precedence',
+    '',
+    'Options:',
+    '-r --range <range>',
+    '        Print versions that match the specified range.',
+    '',
+    '-i --increment [<level>]',
+    '        Increment a version by the specified level.  Level can',
+    '        be one of: major, minor, patch, premajor, preminor,',
+    "        prepatch, or prerelease.  Default level is 'patch'.",
+    '        Only one version may be specified.',
+    '',
+    '--preid <identifier>',
+    '        Identifier to be used to prefix premajor, preminor,',
+    '        prepatch or prerelease version increments.',
+    '',
+    '-l --loose',
+    '        Interpret versions and ranges loosely',
+    '',
+    '-p --include-prerelease',
+    '        Always include prerelease versions in range matching',
+    '',
+    '-c --coerce',
+    '        Coerce a string into SemVer if possible',
+    '        (does not imply --loose)',
+    '',
+    'Program exits successfully if any valid version satisfies',
+    'all supplied ranges, and prints all satisfying versions.',
+    '',
+    'If no satisfying versions are found, then exits failure.',
+    '',
+    'Versions are printed in ascending order, so supplying',
+    'multiple versions to the utility will just sort them.'
+  ].join('\n'))
+}

node_modules/editorconfig/node_modules/semver/package.json

@@ -0,0 +1,63 @@
+{
+  "_args": [
+    [
+      "semver@5.7.1",
+      "/Users/tatiana/selfdefined"
+    ]
+  ],
+  "_from": "semver@5.7.1",
+  "_id": "semver@5.7.1",
+  "_inBundle": false,
+  "_integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+  "_location": "/editorconfig/semver",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "semver@5.7.1",
+    "name": "semver",
+    "escapedName": "semver",
+    "rawSpec": "5.7.1",
+    "saveSpec": null,
+    "fetchSpec": "5.7.1"
+  },
+  "_requiredBy": [
+    "/editorconfig"
+  ],
+  "_resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+  "_spec": "5.7.1",
+  "_where": "/Users/tatiana/selfdefined",
+  "bin": {
+    "semver": "./bin/semver"
+  },
+  "bugs": {
+    "url": "https://github.com/npm/node-semver/issues"
+  },
+  "description": "The semantic version parser used by npm.",
+  "devDependencies": {
+    "tap": "^13.0.0-rc.18"
+  },
+  "files": [
+    "bin",
+    "range.bnf",
+    "semver.js"
+  ],
+  "homepage": "https://github.com/npm/node-semver#readme",
+  "license": "ISC",
+  "main": "semver.js",
+  "name": "semver",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/node-semver.git"
+  },
+  "scripts": {
+    "postpublish": "git push origin --all; git push origin --tags",
+    "postversion": "npm publish",
+    "preversion": "npm test",
+    "test": "tap"
+  },
+  "tap": {
+    "check-coverage": true
+  },
+  "version": "5.7.1"
+}

node_modules/editorconfig/node_modules/semver/range.bnf

@@ -0,0 +1,16 @@
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | [1-9] ( [0-9] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+

node_modules/editorconfig/package.json

@@ -0,0 +1,104 @@
+{
+  "_args": [
+    [
+      "editorconfig@0.15.3",
+      "/Users/tatiana/selfdefined"
+    ]
+  ],
+  "_from": "editorconfig@0.15.3",
+  "_id": "editorconfig@0.15.3",
+  "_inBundle": false,
+  "_integrity": "sha512-M9wIMFx96vq0R4F+gRpY3o2exzb8hEj/n9S8unZtHSvYjibBp/iMufSzvmOcV/laG0ZtuTVGtiJggPOSW2r93g==",
+  "_location": "/editorconfig",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "editorconfig@0.15.3",
+    "name": "editorconfig",
+    "escapedName": "editorconfig",
+    "rawSpec": "0.15.3",
+    "saveSpec": null,
+    "fetchSpec": "0.15.3"
+  },
+  "_requiredBy": [
+    "/js-beautify"
+  ],
+  "_resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-0.15.3.tgz",
+  "_spec": "0.15.3",
+  "_where": "/Users/tatiana/selfdefined",
+  "author": {
+    "name": "EditorConfig Team"
+  },
+  "bin": {
+    "editorconfig": "bin/editorconfig"
+  },
+  "bugs": {
+    "url": "https://github.com/editorconfig/editorconfig-core-js/issues"
+  },
+  "contributors": [
+    {
+      "name": "Hong Xu",
+      "url": "topbug.net"
+    },
+    {
+      "name": "Jed Mao",
+      "url": "https://github.com/jedmao/"
+    },
+    {
+      "name": "Trey Hunner",
+      "url": "http://treyhunner.com"
+    }
+  ],
+  "dependencies": {
+    "commander": "^2.19.0",
+    "lru-cache": "^4.1.5",
+    "semver": "^5.6.0",
+    "sigmund": "^1.0.1"
+  },
+  "description": "EditorConfig File Locator and Interpreter for Node.js",
+  "devDependencies": {
+    "@types/mocha": "^5.2.6",
+    "@types/node": "^10.12.29",
+    "@types/semver": "^5.5.0",
+    "cpy-cli": "^2.0.0",
+    "eclint": "^2.8.1",
+    "mocha": "^5.2.0",
+    "rimraf": "^2.6.3",
+    "should": "^13.2.3",
+    "tslint": "^5.13.1",
+    "typescript": "^3.3.3333"
+  },
+  "directories": {
+    "bin": "./bin",
+    "lib": "./lib"
+  },
+  "homepage": "https://github.com/editorconfig/editorconfig-core-js#readme",
+  "keywords": [
+    "editorconfig",
+    "core"
+  ],
+  "license": "MIT",
+  "main": "src/index.js",
+  "name": "editorconfig",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/editorconfig/editorconfig-core-js.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "copy": "cpy .npmignore LICENSE README.md CHANGELOG.md dist && cpy bin/* dist/bin && cpy src/lib/fnmatch*.* dist/src/lib",
+    "eclint": "eclint check --indent_size ignore \"src/**\"",
+    "lint": "npm run eclint && npm run tslint",
+    "prebuild": "npm run clean",
+    "prepub": "npm run lint && npm run build && npm run copy",
+    "pretest": "npm run lint && npm run build && npm run copy && cmake .",
+    "pretest:ci": "npm run pretest",
+    "pub": "npm publish ./dist",
+    "test": "ctest .",
+    "test:ci": "ctest -VV --output-on-failure .",
+    "tslint": "tslint --project tsconfig.json --exclude package.json"
+  },
+  "version": "0.15.3"
+}

node_modules/editorconfig/src/cli.d.ts

@@ -0,0 +1 @@
+export default function cli(args: string[]): void;

node_modules/editorconfig/src/cli.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tslint:disable:no-console
+var commander_1 = __importDefault(require("commander"));
+var editorconfig = __importStar(require("./"));
+var package_json_1 = __importDefault(require("../package.json"));
+function cli(args) {
+    commander_1.default.version('EditorConfig Node.js Core Version ' + package_json_1.default.version);
+    commander_1.default
+        .usage([
+        '[OPTIONS] FILEPATH1 [FILEPATH2 FILEPATH3 ...]',
+        commander_1.default._version,
+        'FILEPATH can be a hyphen (-) if you want path(s) to be read from stdin.',
+    ].join('\n\n  '))
+        .option('-f <path>', 'Specify conf filename other than \'.editorconfig\'')
+        .option('-b <version>', 'Specify version (used by devs to test compatibility)')
+        .option('-v, --version', 'Display version information')
+        .parse(args);
+    // Throw away the native -V flag in lieu of the one we've manually specified
+    // to adhere to testing requirements
+    commander_1.default.options.shift();
+    var files = commander_1.default.args;
+    if (!files.length) {
+        commander_1.default.help();
+    }
+    files
+        .map(function (filePath) { return editorconfig.parse(filePath, {
+        config: commander_1.default.F,
+        version: commander_1.default.B,
+    }); })
+        .forEach(function (parsing, i, _a) {
+        var length = _a.length;
+        parsing.then(function (parsed) {
+            if (length > 1) {
+                console.log("[" + files[i] + "]");
+            }
+            Object.keys(parsed).forEach(function (key) {
+                console.log(key + "=" + parsed[key]);
+            });
+        });
+    });
+}
+exports.default = cli;

node_modules/editorconfig/src/index.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { parseString, ParseStringResult } from './lib/ini';
+export { parseString };
+export interface KnownProps {
+    end_of_line?: 'lf' | 'crlf' | 'unset';
+    indent_style?: 'tab' | 'space' | 'unset';
+    indent_size?: number | 'tab' | 'unset';
+    insert_final_newline?: true | false | 'unset';
+    tab_width?: number | 'unset';
+    trim_trailing_whitespace?: true | false | 'unset';
+    charset?: string | 'unset';
+}
+export interface ECFile {
+    name: string;
+    contents: string | Buffer;
+}
+export interface FileConfig {
+    name: string;
+    contents: ParseStringResult;
+}
+export interface ParseOptions {
+    config?: string;
+    version?: string;
+    root?: string;
+}
+export declare function parseFromFiles(filepath: string, files: Promise<ECFile[]>, options?: ParseOptions): Promise<KnownProps>;
+export declare function parseFromFilesSync(filepath: string, files: ECFile[], options?: ParseOptions): KnownProps;
+export declare function parse(_filepath: string, _options?: ParseOptions): Promise<KnownProps>;
+export declare function parseSync(_filepath: string, _options?: ParseOptions): KnownProps;

node_modules/editorconfig/src/index.js

@@ -0,0 +1,261 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = __importStar(require("fs"));
+var path = __importStar(require("path"));
+var semver = __importStar(require("semver"));
+var fnmatch_1 = __importDefault(require("./lib/fnmatch"));
+var ini_1 = require("./lib/ini");
+exports.parseString = ini_1.parseString;
+var package_json_1 = __importDefault(require("../package.json"));
+var knownProps = {
+    end_of_line: true,
+    indent_style: true,
+    indent_size: true,
+    insert_final_newline: true,
+    trim_trailing_whitespace: true,
+    charset: true,
+};
+function fnmatch(filepath, glob) {
+    var matchOptions = { matchBase: true, dot: true, noext: true };
+    glob = glob.replace(/\*\*/g, '{*,**/**/**}');
+    return fnmatch_1.default(filepath, glob, matchOptions);
+}
+function getConfigFileNames(filepath, options) {
+    var paths = [];
+    do {
+        filepath = path.dirname(filepath);
+        paths.push(path.join(filepath, options.config));
+    } while (filepath !== options.root);
+    return paths;
+}
+function processMatches(matches, version) {
+    // Set indent_size to 'tab' if indent_size is unspecified and
+    // indent_style is set to 'tab'.
+    if ('indent_style' in matches
+        && matches.indent_style === 'tab'
+        && !('indent_size' in matches)
+        && semver.gte(version, '0.10.0')) {
+        matches.indent_size = 'tab';
+    }
+    // Set tab_width to indent_size if indent_size is specified and
+    // tab_width is unspecified
+    if ('indent_size' in matches
+        && !('tab_width' in matches)
+        && matches.indent_size !== 'tab') {
+        matches.tab_width = matches.indent_size;
+    }
+    // Set indent_size to tab_width if indent_size is 'tab'
+    if ('indent_size' in matches
+        && 'tab_width' in matches
+        && matches.indent_size === 'tab') {
+        matches.indent_size = matches.tab_width;
+    }
+    return matches;
+}
+function processOptions(options, filepath) {
+    if (options === void 0) { options = {}; }
+    return {
+        config: options.config || '.editorconfig',
+        version: options.version || package_json_1.default.version,
+        root: path.resolve(options.root || path.parse(filepath).root),
+    };
+}
+function buildFullGlob(pathPrefix, glob) {
+    switch (glob.indexOf('/')) {
+        case -1:
+            glob = '**/' + glob;
+            break;
+        case 0:
+            glob = glob.substring(1);
+            break;
+        default:
+            break;
+    }
+    return path.join(pathPrefix, glob);
+}
+function extendProps(props, options) {
+    if (props === void 0) { props = {}; }
+    if (options === void 0) { options = {}; }
+    for (var key in options) {
+        if (options.hasOwnProperty(key)) {
+            var value = options[key];
+            var key2 = key.toLowerCase();
+            var value2 = value;
+            if (knownProps[key2]) {
+                value2 = value.toLowerCase();
+            }
+            try {
+                value2 = JSON.parse(value);
+            }
+            catch (e) { }
+            if (typeof value === 'undefined' || value === null) {
+                // null and undefined are values specific to JSON (no special meaning
+                // in editorconfig) & should just be returned as regular strings.
+                value2 = String(value);
+            }
+            props[key2] = value2;
+        }
+    }
+    return props;
+}
+function parseFromConfigs(configs, filepath, options) {
+    return processMatches(configs
+        .reverse()
+        .reduce(function (matches, file) {
+        var pathPrefix = path.dirname(file.name);
+        file.contents.forEach(function (section) {
+            var glob = section[0];
+            var options2 = section[1];
+            if (!glob) {
+                return;
+            }
+            var fullGlob = buildFullGlob(pathPrefix, glob);
+            if (!fnmatch(filepath, fullGlob)) {
+                return;
+            }
+            matches = extendProps(matches, options2);
+        });
+        return matches;
+    }, {}), options.version);
+}
+function getConfigsForFiles(files) {
+    var configs = [];
+    for (var i in files) {
+        if (files.hasOwnProperty(i)) {
+            var file = files[i];
+            var contents = ini_1.parseString(file.contents);
+            configs.push({
+                name: file.name,
+                contents: contents,
+            });
+            if ((contents[0][1].root || '').toLowerCase() === 'true') {
+                break;
+            }
+        }
+    }
+    return configs;
+}
+function readConfigFiles(filepaths) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, Promise.all(filepaths.map(function (name) { return new Promise(function (resolve) {
+                    fs.readFile(name, 'utf8', function (err, data) {
+                        resolve({
+                            name: name,
+                            contents: err ? '' : data,
+                        });
+                    });
+                }); }))];
+        });
+    });
+}
+function readConfigFilesSync(filepaths) {
+    var files = [];
+    var file;
+    filepaths.forEach(function (filepath) {
+        try {
+            file = fs.readFileSync(filepath, 'utf8');
+        }
+        catch (e) {
+            file = '';
+        }
+        files.push({
+            name: filepath,
+            contents: file,
+        });
+    });
+    return files;
+}
+function opts(filepath, options) {
+    if (options === void 0) { options = {}; }
+    var resolvedFilePath = path.resolve(filepath);
+    return [
+        resolvedFilePath,
+        processOptions(options, resolvedFilePath),
+    ];
+}
+function parseFromFiles(filepath, files, options) {
+    if (options === void 0) { options = {}; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, resolvedFilePath, processedOptions;
+        return __generator(this, function (_b) {
+            _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1];
+            return [2 /*return*/, files.then(getConfigsForFiles)
+                    .then(function (configs) { return parseFromConfigs(configs, resolvedFilePath, processedOptions); })];
+        });
+    });
+}
+exports.parseFromFiles = parseFromFiles;
+function parseFromFilesSync(filepath, files, options) {
+    if (options === void 0) { options = {}; }
+    var _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1];
+    return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions);
+}
+exports.parseFromFilesSync = parseFromFilesSync;
+function parse(_filepath, _options) {
+    if (_options === void 0) { _options = {}; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, resolvedFilePath, processedOptions, filepaths;
+        return __generator(this, function (_b) {
+            _a = opts(_filepath, _options), resolvedFilePath = _a[0], processedOptions = _a[1];
+            filepaths = getConfigFileNames(resolvedFilePath, processedOptions);
+            return [2 /*return*/, readConfigFiles(filepaths)
+                    .then(getConfigsForFiles)
+                    .then(function (configs) { return parseFromConfigs(configs, resolvedFilePath, processedOptions); })];
+        });
+    });
+}
+exports.parse = parse;
+function parseSync(_filepath, _options) {
+    if (_options === void 0) { _options = {}; }
+    var _a = opts(_filepath, _options), resolvedFilePath = _a[0], processedOptions = _a[1];
+    var filepaths = getConfigFileNames(resolvedFilePath, processedOptions);
+    var files = readConfigFilesSync(filepaths);
+    return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions);
+}
+exports.parseSync = parseSync;

node_modules/editorconfig/src/lib/fnmatch.d.ts

@@ -0,0 +1,214 @@
+// Type definitions for Minimatch 3.0
+// Project: https://github.com/isaacs/minimatch
+// Definitions by: vvakame <https://github.com/vvakame>
+//                 Shant Marouti <https://github.com/shantmarouti>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * Tests a path against the pattern using the options.
+ */
+declare function M(target: string, pattern: string, options?: M.IOptions): boolean;
+
+declare namespace M {
+    /**
+     * Match against the list of files, in the style of fnmatch or glob.
+     * If nothing is matched, and options.nonull is set,
+     * then return a list containing the pattern itself.
+     */
+    function match(list: string[], pattern: string, options?: IOptions): string[];
+
+    /**
+     * Returns a function that tests its supplied argument, suitable for use with Array.filter
+     */
+    function filter(pattern: string, options?: IOptions): (element: string, indexed: number, array: string[]) => boolean;
+
+    /**
+     * Make a regular expression object from the pattern.
+     */
+    function makeRe(pattern: string, options?: IOptions): RegExp;
+
+    var Minimatch: IMinimatchStatic;
+
+    interface IOptions {
+        /**
+         * Dump a ton of stuff to stderr.
+         *
+         * @default false
+         */
+        debug?: boolean;
+
+        /**
+         * Do not expand {a,b} and {1..3} brace sets.
+         *
+         * @default false
+         */
+        nobrace?: boolean;
+
+        /**
+         * Disable ** matching against multiple folder names.
+         *
+         * @default false
+         */
+        noglobstar?: boolean;
+
+        /**
+         * Allow patterns to match filenames starting with a period,
+         * even if the pattern does not explicitly have a period in that spot.
+         *
+         * @default false
+         */
+        dot?: boolean;
+
+        /**
+         * Disable "extglob" style patterns like +(a|b).
+         *
+         * @default false
+         */
+        noext?: boolean;
+
+        /**
+         * Perform a case-insensitive match.
+         *
+         * @default false
+         */
+        nocase?: boolean;
+
+        /**
+         * When a match is not found by minimatch.match,
+         * return a list containing the pattern itself if this option is set.
+         * Otherwise, an empty list is returned if there are no matches.
+         *
+         * @default false
+         */
+        nonull?: boolean;
+
+        /**
+         * If set, then patterns without slashes will be matched against
+         * the basename of the path if it contains slashes.
+         *
+         * @default false
+         */
+        matchBase?: boolean;
+
+        /**
+         * Suppress the behavior of treating #
+         * at the start of a pattern as a comment.
+         *
+         * @default false
+         */
+        nocomment?: boolean;
+
+        /**
+         * Suppress the behavior of treating a leading ! character as negation.
+         *
+         * @default false
+         */
+        nonegate?: boolean;
+
+        /**
+         * Returns from negate expressions the same as if they were not negated.
+         * (Ie, true on a hit, false on a miss.)
+         *
+         * @default false
+         */
+        flipNegate?: boolean;
+    }
+
+    interface IMinimatchStatic {
+        new(pattern: string, options?: IOptions): IMinimatch;
+        prototype: IMinimatch;
+    }
+
+    interface IMinimatch {
+        /**
+         * The original pattern the minimatch object represents.
+         */
+        pattern: string;
+
+        /**
+         * The options supplied to the constructor.
+         */
+        options: IOptions;
+
+        /**
+         * A 2-dimensional array of regexp or string expressions.
+         */
+        set: any[][]; // (RegExp | string)[][]
+
+        /**
+         * A single regular expression expressing the entire pattern.
+         * Created by the makeRe method.
+         */
+        regexp: RegExp;
+
+        /**
+         * True if the pattern is negated.
+         */
+        negate: boolean;
+
+        /**
+         * True if the pattern is a comment.
+         */
+        comment: boolean;
+
+        /**
+         * True if the pattern is ""
+         */
+        empty: boolean;
+
+        /**
+         * Generate the regexp member if necessary, and return it.
+         * Will return false if the pattern is invalid.
+         */
+        makeRe(): RegExp; // regexp or boolean
+
+        /**
+         * Return true if the filename matches the pattern, or false otherwise.
+         */
+        match(fname: string): boolean;
+
+        /**
+         * Take a /-split filename, and match it against a single row in the regExpSet.
+         * This method is mainly for internal use, but is exposed so that it can be used
+         * by a glob-walker that needs to avoid excessive filesystem calls.
+         */
+        matchOne(files: string[], pattern: string[], partial: boolean): boolean;
+
+        /**
+         * Deprecated. For internal use.
+         *
+         * @private
+         */
+        debug(): void;
+
+        /**
+         * Deprecated. For internal use.
+         *
+         * @private
+         */
+        make(): void;
+
+        /**
+         * Deprecated. For internal use.
+         *
+         * @private
+         */
+        parseNegate(): void;
+
+        /**
+         * Deprecated. For internal use.
+         *
+         * @private
+         */
+        braceExpand(pattern: string, options: IOptions): void;
+
+        /**
+         * Deprecated. For internal use.
+         *
+         * @private
+         */
+        parse(pattern: string, isSub?: boolean): void;
+    }
+}
+
+export = M;

node_modules/editorconfig/src/lib/ini.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { URL } from 'url';
+/**
+ * Parses an .ini file
+ * @param file The location of the .ini file
+ */
+export declare function parse(file: string | number | Buffer | URL): Promise<[string | null, SectionBody][]>;
+export declare function parseSync(file: string | number | Buffer | URL): [string | null, SectionBody][];
+export declare type SectionName = string | null;
+export interface SectionBody {
+    [key: string]: string;
+}
+export declare type ParseStringResult = Array<[SectionName, SectionBody]>;
+export declare function parseString(data: string): ParseStringResult;

node_modules/editorconfig/src/lib/ini.js

@@ -0,0 +1,106 @@
+"use strict";
+// Based on iniparser by shockie <https://npmjs.org/package/iniparser>
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = __importStar(require("fs"));
+/**
+ * define the possible values:
+ * section: [section]
+ * param: key=value
+ * comment: ;this is a comment
+ */
+var regex = {
+    section: /^\s*\[(([^#;]|\\#|\\;)+)\]\s*([#;].*)?$/,
+    param: /^\s*([\w\.\-\_]+)\s*[=:]\s*(.*?)\s*([#;].*)?$/,
+    comment: /^\s*[#;].*$/,
+};
+/**
+ * Parses an .ini file
+ * @param file The location of the .ini file
+ */
+function parse(file) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    fs.readFile(file, 'utf8', function (err, data) {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        resolve(parseString(data));
+                    });
+                })];
+        });
+    });
+}
+exports.parse = parse;
+function parseSync(file) {
+    return parseString(fs.readFileSync(file, 'utf8'));
+}
+exports.parseSync = parseSync;
+function parseString(data) {
+    var sectionBody = {};
+    var sectionName = null;
+    var value = [[sectionName, sectionBody]];
+    var lines = data.split(/\r\n|\r|\n/);
+    lines.forEach(function (line) {
+        var match;
+        if (regex.comment.test(line)) {
+            return;
+        }
+        if (regex.param.test(line)) {
+            match = line.match(regex.param);
+            sectionBody[match[1]] =
+                match[2];
+        }
+        else if (regex.section.test(line)) {
+            match = line.match(regex.section);
+            sectionName = match[1];
+            sectionBody = {};
+            value.push([sectionName, sectionBody]);
+        }
+    });
+    return value;
+}
+exports.parseString = parseString;