aboutsummaryrefslogtreecommitdiff
path: root/_mint/node_modules/editorconfig
diff options
context:
space:
mode:
Diffstat (limited to '_mint/node_modules/editorconfig')
-rw-r--r--_mint/node_modules/editorconfig/CHANGELOG.md14
-rw-r--r--_mint/node_modules/editorconfig/LICENSE19
-rw-r--r--_mint/node_modules/editorconfig/README.md206
-rw-r--r--_mint/node_modules/editorconfig/bin/editorconfig3
-rw-r--r--_mint/node_modules/editorconfig/package.json59
-rw-r--r--_mint/node_modules/editorconfig/src/cli.d.ts1
-rw-r--r--_mint/node_modules/editorconfig/src/cli.js53
-rw-r--r--_mint/node_modules/editorconfig/src/index.d.ts29
-rw-r--r--_mint/node_modules/editorconfig/src/index.js261
-rw-r--r--_mint/node_modules/editorconfig/src/lib/fnmatch.d.ts214
-rw-r--r--_mint/node_modules/editorconfig/src/lib/fnmatch.js1047
-rw-r--r--_mint/node_modules/editorconfig/src/lib/ini.d.ts14
-rw-r--r--_mint/node_modules/editorconfig/src/lib/ini.js106
13 files changed, 2026 insertions, 0 deletions
diff --git a/_mint/node_modules/editorconfig/CHANGELOG.md b/_mint/node_modules/editorconfig/CHANGELOG.md
new file mode 100644
index 0000000..1589853
--- /dev/null
+++ b/_mint/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.
diff --git a/_mint/node_modules/editorconfig/LICENSE b/_mint/node_modules/editorconfig/LICENSE
new file mode 100644
index 0000000..85329c8
--- /dev/null
+++ b/_mint/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.
diff --git a/_mint/node_modules/editorconfig/README.md b/_mint/node_modules/editorconfig/README.md
new file mode 100644
index 0000000..6ff281a
--- /dev/null
+++ b/_mint/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
diff --git a/_mint/node_modules/editorconfig/bin/editorconfig b/_mint/node_modules/editorconfig/bin/editorconfig
new file mode 100644
index 0000000..a7792ac
--- /dev/null
+++ b/_mint/node_modules/editorconfig/bin/editorconfig
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+var cli = require('../src/cli')
+cli.default(process.argv)
diff --git a/_mint/node_modules/editorconfig/package.json b/_mint/node_modules/editorconfig/package.json
new file mode 100644
index 0000000..3cb53cb
--- /dev/null
+++ b/_mint/node_modules/editorconfig/package.json
@@ -0,0 +1,59 @@
+{
+ "name": "editorconfig",
+ "version": "0.15.3",
+ "description": "EditorConfig File Locator and Interpreter for Node.js",
+ "keywords": [
+ "editorconfig",
+ "core"
+ ],
+ "main": "src/index.js",
+ "contributors": [
+ "Hong Xu (topbug.net)",
+ "Jed Mao (https://github.com/jedmao/)",
+ "Trey Hunner (http://treyhunner.com)"
+ ],
+ "directories": {
+ "bin": "./bin",
+ "lib": "./lib"
+ },
+ "scripts": {
+ "clean": "rimraf dist",
+ "prebuild": "npm run clean",
+ "build": "tsc",
+ "pretest": "npm run lint && npm run build && npm run copy && cmake .",
+ "test": "ctest .",
+ "pretest:ci": "npm run pretest",
+ "test:ci": "ctest -VV --output-on-failure .",
+ "lint": "npm run eclint && npm run tslint",
+ "eclint": "eclint check --indent_size ignore \"src/**\"",
+ "tslint": "tslint --project tsconfig.json --exclude package.json",
+ "copy": "cpy .npmignore LICENSE README.md CHANGELOG.md dist && cpy bin/* dist/bin && cpy src/lib/fnmatch*.* dist/src/lib",
+ "prepub": "npm run lint && npm run build && npm run copy",
+ "pub": "npm publish ./dist"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/editorconfig/editorconfig-core-js.git"
+ },
+ "bugs": "https://github.com/editorconfig/editorconfig-core-js/issues",
+ "author": "EditorConfig Team",
+ "license": "MIT",
+ "dependencies": {
+ "commander": "^2.19.0",
+ "lru-cache": "^4.1.5",
+ "semver": "^5.6.0",
+ "sigmund": "^1.0.1"
+ },
+ "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"
+ }
+}
diff --git a/_mint/node_modules/editorconfig/src/cli.d.ts b/_mint/node_modules/editorconfig/src/cli.d.ts
new file mode 100644
index 0000000..b6c6640
--- /dev/null
+++ b/_mint/node_modules/editorconfig/src/cli.d.ts
@@ -0,0 +1 @@
+export default function cli(args: string[]): void;
diff --git a/_mint/node_modules/editorconfig/src/cli.js b/_mint/node_modules/editorconfig/src/cli.js
new file mode 100644
index 0000000..0589b0c
--- /dev/null
+++ b/_mint/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;
diff --git a/_mint/node_modules/editorconfig/src/index.d.ts b/_mint/node_modules/editorconfig/src/index.d.ts
new file mode 100644
index 0000000..1a69317
--- /dev/null
+++ b/_mint/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;
diff --git a/_mint/node_modules/editorconfig/src/index.js b/_mint/node_modules/editorconfig/src/index.js
new file mode 100644
index 0000000..6086366
--- /dev/null
+++ b/_mint/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;
diff --git a/_mint/node_modules/editorconfig/src/lib/fnmatch.d.ts b/_mint/node_modules/editorconfig/src/lib/fnmatch.d.ts
new file mode 100644
index 0000000..5c9bd38
--- /dev/null
+++ b/_mint/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;
diff --git a/_mint/node_modules/editorconfig/src/lib/fnmatch.js b/_mint/node_modules/editorconfig/src/lib/fnmatch.js
new file mode 100644
index 0000000..240ce33
--- /dev/null
+++ b/_mint/node_modules/editorconfig/src/lib/fnmatch.js
@@ -0,0 +1,1047 @@
+// Based on minimatch.js by isaacs <https://npmjs.org/package/minimatch>
+
+ var platform = typeof process === "object" ? process.platform : "win32"
+
+ if (module) module.exports = minimatch
+ else exports.minimatch = minimatch
+
+ minimatch.Minimatch = Minimatch
+
+ var LRU = require("lru-cache")
+ , cache = minimatch.cache = new LRU({max: 100})
+ , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
+ , sigmund = require("sigmund")
+
+ var path = require("path")
+ // any single thing other than /
+ // don't need to escape / when using new RegExp()
+ , qmark = "[^/]"
+
+ // * => any number of characters
+ , star = qmark + "*?"
+
+ // ** when dots are allowed. Anything goes, except .. and .
+ // not (^ or / followed by one or two dots followed by $ or /),
+ // followed by anything, any number of times.
+ , twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?"
+
+ // not a ^ or / followed by a dot,
+ // followed by anything, any number of times.
+ , twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?"
+
+ // characters that need to be escaped in RegExp.
+ , reSpecials = charSet("().*{}+?[]^$\\!")
+
+// "abc" -> { a:true, b:true, c:true }
+ function charSet (s) {
+ return s.split("").reduce(function (set, c) {
+ set[c] = true
+ return set
+ }, {})
+ }
+
+// normalizes slashes.
+ var slashSplit = /\/+/
+
+ minimatch.monkeyPatch = monkeyPatch
+ function monkeyPatch () {
+ var desc = Object.getOwnPropertyDescriptor(String.prototype, "match")
+ var orig = desc.value
+ desc.value = function (p) {
+ if (p instanceof Minimatch) return p.match(this)
+ return orig.call(this, p)
+ }
+ Object.defineProperty(String.prototype, desc)
+ }
+
+ minimatch.filter = filter
+ function filter (pattern, options) {
+ options = options || {}
+ return function (p, i, list) {
+ return minimatch(p, pattern, options)
+ }
+ }
+
+ function ext (a, b) {
+ a = a || {}
+ b = b || {}
+ var t = {}
+ Object.keys(b).forEach(function (k) {
+ t[k] = b[k]
+ })
+ Object.keys(a).forEach(function (k) {
+ t[k] = a[k]
+ })
+ return t
+ }
+
+ minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return minimatch
+
+ var orig = minimatch
+
+ var m = function minimatch (p, pattern, options) {
+ return orig.minimatch(p, pattern, ext(def, options))
+ }
+
+ m.Minimatch = function Minimatch (pattern, options) {
+ return new orig.Minimatch(pattern, ext(def, options))
+ }
+
+ return m
+ }
+
+ Minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return Minimatch
+ return minimatch.defaults(def).Minimatch
+ }
+
+
+ function minimatch (p, pattern, options) {
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required")
+ }
+
+ if (!options) options = {}
+
+ // shortcut: comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ return false
+ }
+
+ // "" only matches ""
+ if (pattern.trim() === "") return p === ""
+
+ return new Minimatch(pattern, options).match(p)
+ }
+
+ function Minimatch (pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options, cache)
+ }
+
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required")
+ }
+
+ if (!options) options = {}
+
+ // windows: need to use /, not \
+ // On other platforms, \ is a valid (albeit bad) filename char.
+ if (platform === "win32") {
+ pattern = pattern.split("\\").join("/")
+ }
+
+ // lru storage.
+ // these things aren't particularly big, but walking down the string
+ // and turning it into a regexp can get pretty costly.
+ var cacheKey = pattern + "\n" + sigmund(options)
+ var cached = minimatch.cache.get(cacheKey)
+ if (cached) return cached
+ minimatch.cache.set(cacheKey, this)
+
+ this.options = options
+ this.set = []
+ this.pattern = pattern
+ this.regexp = null
+ this.negate = false
+ this.comment = false
+ this.empty = false
+
+ // make the set of regexps etc.
+ this.make()
+ }
+
+ Minimatch.prototype.make = make
+ function make () {
+ // don't do it more than once.
+ if (this._made) return
+
+ var pattern = this.pattern
+ var options = this.options
+
+ // empty patterns and comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ this.comment = true
+ return
+ }
+ if (!pattern) {
+ this.empty = true
+ return
+ }
+
+ // step 1: figure out negation, etc.
+ this.parseNegate()
+
+ // step 2: expand braces
+ var set = this.globSet = this.braceExpand()
+
+ if (options.debug) console.error(this.pattern, set)
+
+ // step 3: now we have a set, so turn each one into a series of path-portion
+ // matching patterns.
+ // These will be regexps, except in the case of "**", which is
+ // set to the GLOBSTAR object for globstar behavior,
+ // and will not contain any / characters
+ set = this.globParts = set.map(function (s) {
+ return s.split(slashSplit)
+ })
+
+ if (options.debug) console.error(this.pattern, set)
+
+ // glob --> regexps
+ set = set.map(function (s, si, set) {
+ return s.map(this.parse, this)
+ }, this)
+
+ if (options.debug) console.error(this.pattern, set)
+
+ // filter out everything that didn't compile properly.
+ set = set.filter(function (s) {
+ return -1 === s.indexOf(false)
+ })
+
+ if (options.debug) console.error(this.pattern, set)
+
+ this.set = set
+ }
+
+ Minimatch.prototype.parseNegate = parseNegate
+ function parseNegate () {
+ var pattern = this.pattern
+ , negate = false
+ , options = this.options
+ , negateOffset = 0
+
+ if (options.nonegate) return
+
+ for ( var i = 0, l = pattern.length
+ ; i < l && pattern.charAt(i) === "!"
+ ; i ++) {
+ negate = !negate
+ negateOffset ++
+ }
+
+ if (negateOffset) this.pattern = pattern.substr(negateOffset)
+ this.negate = negate
+ }
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+ minimatch.braceExpand = function (pattern, options) {
+ return new Minimatch(pattern, options).braceExpand()
+ }
+
+ Minimatch.prototype.braceExpand = braceExpand
+ function braceExpand (pattern, options) {
+ options = options || this.options
+ pattern = typeof pattern === "undefined"
+ ? this.pattern : pattern
+
+ if (typeof pattern === "undefined") {
+ throw new Error("undefined pattern")
+ }
+
+ if (options.nobrace ||
+ !pattern.match(/\{.*\}/)) {
+ // shortcut. no need to expand.
+ return [pattern]
+ }
+
+ var escaping = false
+
+ // examples and comments refer to this crazy pattern:
+ // a{b,c{d,e},{f,g}h}x{y,z}
+ // expected:
+ // abxy
+ // abxz
+ // acdxy
+ // acdxz
+ // acexy
+ // acexz
+ // afhxy
+ // afhxz
+ // aghxy
+ // aghxz
+
+ // everything before the first \{ is just a prefix.
+ // So, we pluck that off, and work with the rest,
+ // and then prepend it to everything we find.
+ if (pattern.charAt(0) !== "{") {
+ // console.error(pattern)
+ var prefix = null
+ for (var i = 0, l = pattern.length; i < l; i ++) {
+ var c = pattern.charAt(i)
+ // console.error(i, c)
+ if (c === "\\") {
+ escaping = !escaping
+ } else if (c === "{" && !escaping) {
+ prefix = pattern.substr(0, i)
+ break
+ }
+ }
+
+ // actually no sets, all { were escaped.
+ if (prefix === null) {
+ // console.error("no sets")
+ return [pattern]
+ }
+
+ var tail = braceExpand(pattern.substr(i), options)
+ return tail.map(function (t) {
+ return prefix + t
+ })
+ }
+
+ // now we have something like:
+ // {b,c{d,e},{f,g}h}x{y,z}
+ // walk through the set, expanding each part, until
+ // the set ends. then, we'll expand the suffix.
+ // If the set only has a single member, then'll put the {} back
+
+ // first, handle numeric sets, since they're easier
+ var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/)
+ if (numset) {
+ // console.error("numset", numset[1], numset[2])
+ var suf = braceExpand(pattern.substr(numset[0].length), options)
+ , start = +numset[1]
+ , end = +numset[2]
+ , inc = start > end ? -1 : 1
+ , set = []
+ for (var i = start; i != (end + inc); i += inc) {
+ // append all the suffixes
+ for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
+ set.push(i + suf[ii])
+ }
+ }
+ return set
+ }
+
+ // ok, walk through the set
+ // We hope, somewhat optimistically, that there
+ // will be a } at the end.
+ // If the closing brace isn't found, then the pattern is
+ // interpreted as braceExpand("\\" + pattern) so that
+ // the leading \{ will be interpreted literally.
+ var i = 1 // skip the \{
+ , depth = 1
+ , set = []
+ , member = ""
+ , sawEnd = false
+ , escaping = false
+
+ function addMember () {
+ set.push(member)
+ member = ""
+ }
+
+ // console.error("Entering for")
+ FOR: for (i = 1, l = pattern.length; i < l; i ++) {
+ var c = pattern.charAt(i)
+ // console.error("", i, c)
+
+ if (escaping) {
+ escaping = false
+ member += "\\" + c
+ } else {
+ switch (c) {
+ case "\\":
+ escaping = true
+ continue
+
+ case "{":
+ depth ++
+ member += "{"
+ continue
+
+ case "}":
+ depth --
+ // if this closes the actual set, then we're done
+ if (depth === 0) {
+ addMember()
+ // pluck off the close-brace
+ i ++
+ break FOR
+ } else {
+ member += c
+ continue
+ }
+
+ case ",":
+ if (depth === 1) {
+ addMember()
+ } else {
+ member += c
+ }
+ continue
+
+ default:
+ member += c
+ continue
+ } // switch
+ } // else
+ } // for
+
+ // now we've either finished the set, and the suffix is
+ // pattern.substr(i), or we have *not* closed the set,
+ // and need to escape the leading brace
+ if (depth !== 0) {
+ // console.error("didn't close", pattern)
+ return braceExpand("\\" + pattern, options)
+ }
+
+ // x{y,z} -> ["xy", "xz"]
+ // console.error("set", set)
+ // console.error("suffix", pattern.substr(i))
+ var suf = braceExpand(pattern.substr(i), options)
+ // ["b", "c{d,e}","{f,g}h"] ->
+ // [["b"], ["cd", "ce"], ["fh", "gh"]]
+ var addBraces = set.length === 1
+ // console.error("set pre-expanded", set)
+ set = set.map(function (p) {
+ return braceExpand(p, options)
+ })
+ // console.error("set expanded", set)
+
+
+ // [["b"], ["cd", "ce"], ["fh", "gh"]] ->
+ // ["b", "cd", "ce", "fh", "gh"]
+ set = set.reduce(function (l, r) {
+ return l.concat(r)
+ })
+
+ if (addBraces) {
+ set = set.map(function (s) {
+ return "{" + s + "}"
+ })
+ }
+
+ // now attach the suffixes.
+ var ret = []
+ for (var i = 0, l = set.length; i < l; i ++) {
+ for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
+ ret.push(set[i] + suf[ii])
+ }
+ }
+ return ret
+ }
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion. Otherwise, any series
+// of * is equivalent to a single *. Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+ Minimatch.prototype.parse = parse
+ var SUBPARSE = {}
+ function parse (pattern, isSub) {
+ var options = this.options
+
+ // shortcuts
+ if (!options.noglobstar && pattern === "**") return GLOBSTAR
+ if (pattern === "") return ""
+
+ var re = ""
+ , hasMagic = !!options.nocase
+ , escaping = false
+ // ? => one single character
+ , patternListStack = []
+ , plType
+ , stateChar
+ , inClass = false
+ , reClassStart = -1
+ , classStart = -1
+ // . and .. never match anything that doesn't start with .,
+ // even when options.dot is set.
+ , patternStart = pattern.charAt(0) === "." ? "" // anything
+ // not (start or / followed by . or .. followed by / or end)
+ : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))"
+ : "(?!\\.)"
+
+ function clearStateChar () {
+ if (stateChar) {
+ // we had some state-tracking character
+ // that wasn't consumed by this pass.
+ switch (stateChar) {
+ case "*":
+ re += star
+ hasMagic = true
+ break
+ case "?":
+ re += qmark
+ hasMagic = true
+ break
+ default:
+ re += "\\"+stateChar
+ break
+ }
+ stateChar = false
+ }
+ }
+
+ for ( var i = 0, len = pattern.length, c
+ ; (i < len) && (c = pattern.charAt(i))
+ ; i ++ ) {
+
+ if (options.debug) {
+ console.error("%s\t%s %s %j", pattern, i, re, c)
+ }
+
+ // skip over any that are escaped.
+ if (escaping && reSpecials[c]) {
+ re += "\\" + c
+ escaping = false
+ continue
+ }
+
+ SWITCH: switch (c) {
+ case "/":
+ // completely not allowed, even escaped.
+ // Should already be path-split by now.
+ return false
+
+ case "\\":
+ clearStateChar()
+ escaping = true
+ continue
+
+ // the various stateChar values
+ // for the "extglob" stuff.
+ case "?":
+ case "*":
+ case "+":
+ case "@":
+ case "!":
+ if (options.debug) {
+ console.error("%s\t%s %s %j <-- stateChar", pattern, i, re, c)
+ }
+
+ // all of those are literals inside a class, except that
+ // the glob [!a] means [^a] in regexp
+ if (inClass) {
+ if (c === "!" && i === classStart + 1) c = "^"
+ re += c
+ continue
+ }
+
+ // if we already have a stateChar, then it means
+ // that there was something like ** or +? in there.
+ // Handle the stateChar, then proceed with this one.
+ clearStateChar()
+ stateChar = c
+ // if extglob is disabled, then +(asdf|foo) isn't a thing.
+ // just clear the statechar *now*, rather than even diving into
+ // the patternList stuff.
+ if (options.noext) clearStateChar()
+ continue
+
+ case "(":
+ if (inClass) {
+ re += "("
+ continue
+ }
+
+ if (!stateChar) {
+ re += "\\("
+ continue
+ }
+
+ plType = stateChar
+ patternListStack.push({ type: plType
+ , start: i - 1
+ , reStart: re.length })
+ // negation is (?:(?!js)[^/]*)
+ re += stateChar === "!" ? "(?:(?!" : "(?:"
+ stateChar = false
+ continue
+
+ case ")":
+ if (inClass || !patternListStack.length) {
+ re += "\\)"
+ continue
+ }
+
+ hasMagic = true
+ re += ")"
+ plType = patternListStack.pop().type
+ // negation is (?:(?!js)[^/]*)
+ // The others are (?:<pattern>)<type>
+ switch (plType) {
+ case "!":
+ re += "[^/]*?)"
+ break
+ case "?":
+ case "+":
+ case "*": re += plType
+ case "@": break // the default anyway
+ }
+ continue
+
+ case "|":
+ if (inClass || !patternListStack.length || escaping) {
+ re += "\\|"
+ escaping = false
+ continue
+ }
+
+ re += "|"
+ continue
+
+ // these are mostly the same in regexp and glob
+ case "[":
+ // swallow any state-tracking char before the [
+ clearStateChar()
+
+ if (inClass) {
+ re += "\\" + c
+ continue
+ }
+
+ inClass = true
+ classStart = i
+ reClassStart = re.length
+ re += c
+ continue
+
+ case "]":
+ // a right bracket shall lose its special
+ // meaning and represent itself in
+ // a bracket expression if it occurs
+ // first in the list. -- POSIX.2 2.8.3.2
+ if (i === classStart + 1 || !inClass) {
+ re += "\\" + c
+ escaping = false
+ continue
+ }
+
+ // finish up the class.
+ hasMagic = true
+ inClass = false
+ re += c
+ continue
+
+ default:
+ // swallow any state char that wasn't consumed
+ clearStateChar()
+
+ if (escaping) {
+ // no need
+ escaping = false
+ } else if (reSpecials[c]
+ && !(c === "^" && inClass)) {
+ re += "\\"
+ }
+
+ re += c
+
+ } // switch
+ } // for
+
+
+ // handle the case where we left a class open.
+ // "[abc" is valid, equivalent to "\[abc"
+ if (inClass) {
+ // split where the last [ was, and escape it
+ // this is a huge pita. We now have to re-walk
+ // the contents of the would-be class to re-translate
+ // any characters that were passed through as-is
+ var cs = pattern.substr(classStart + 1)
+ , sp = this.parse(cs, SUBPARSE)
+ re = re.substr(0, reClassStart) + "\\[" + sp[0]
+ hasMagic = hasMagic || sp[1]
+ }
+
+ // handle the case where we had a +( thing at the *end*
+ // of the pattern.
+ // each pattern list stack adds 3 chars, and we need to go through
+ // and escape any | chars that were passed through as-is for the regexp.
+ // Go through and escape them, taking care not to double-escape any
+ // | chars that were already escaped.
+ var pl
+ while (pl = patternListStack.pop()) {
+ var tail = re.slice(pl.reStart + 3)
+ // maybe some even number of \, then maybe 1 \, followed by a |
+ tail = tail.replace(/((?:\\{2})*)(\\?)\|/g, function (_, $1, $2) {
+ if (!$2) {
+ // the | isn't already escaped, so escape it.
+ $2 = "\\"
+ }
+
+ // need to escape all those slashes *again*, without escaping the
+ // one that we need for escaping the | character. As it works out,
+ // escaping an even number of slashes can be done by simply repeating
+ // it exactly after itself. That's why this trick works.
+ //
+ // I am sorry that you have to see this.
+ return $1 + $1 + $2 + "|"
+ })
+
+ // console.error("tail=%j\n %s", tail, tail)
+ var t = pl.type === "*" ? star
+ : pl.type === "?" ? qmark
+ : "\\" + pl.type
+
+ hasMagic = true
+ re = re.slice(0, pl.reStart)
+ + t + "\\("
+ + tail
+ }
+
+ // handle trailing things that only matter at the very end.
+ clearStateChar()
+ if (escaping) {
+ // trailing \\
+ re += "\\\\"
+ }
+
+ // only need to apply the nodot start if the re starts with
+ // something that could conceivably capture a dot
+ var addPatternStart = false
+ switch (re.charAt(0)) {
+ case ".":
+ case "[":
+ case "(": addPatternStart = true
+ }
+
+ // if the re is not "" at this point, then we need to make sure
+ // it doesn't match against an empty path part.
+ // Otherwise a/* will match a/, which it should not.
+ if (re !== "" && hasMagic) re = "(?=.)" + re
+
+ if (addPatternStart) re = patternStart + re
+
+ // parsing just a piece of a larger pattern.
+ if (isSub === SUBPARSE) {
+ return [ re, hasMagic ]
+ }
+
+ // skip the regexp for non-magical patterns
+ // unescape anything in it, though, so that it'll be
+ // an exact match against a file etc.
+ if (!hasMagic) {
+ return globUnescape(pattern)
+ }
+
+ var flags = options.nocase ? "i" : ""
+ , regExp = new RegExp("^" + re + "$", flags)
+
+ regExp._glob = pattern
+ regExp._src = re
+
+ return regExp
+ }
+
+ minimatch.makeRe = function (pattern, options) {
+ return new Minimatch(pattern, options || {}).makeRe()
+ }
+
+ Minimatch.prototype.makeRe = makeRe
+ function makeRe () {
+ if (this.regexp || this.regexp === false) return this.regexp
+
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ var set = this.set
+
+ if (!set.length) return this.regexp = false
+ var options = this.options
+
+ var twoStar = options.noglobstar ? star
+ : options.dot ? twoStarDot
+ : twoStarNoDot
+ , flags = options.nocase ? "i" : ""
+
+ var re = set.map(function (pattern) {
+ return pattern.map(function (p) {
+ return (p === GLOBSTAR) ? twoStar
+ : (typeof p === "string") ? regExpEscape(p)
+ : p._src
+ }).join("\\\/")
+ }).join("|")
+
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = "^(?:" + re + ")$"
+
+ // can match anything, as long as it's not this.
+ if (this.negate) re = "^(?!" + re + ").*$"
+
+ try {
+ return this.regexp = new RegExp(re, flags)
+ } catch (ex) {
+ return this.regexp = false
+ }
+ }
+
+ minimatch.match = function (list, pattern, options) {
+ var mm = new Minimatch(pattern, options)
+ list = list.filter(function (f) {
+ return mm.match(f)
+ })
+ if (options.nonull && !list.length) {
+ list.push(pattern)
+ }
+ return list
+ }
+
+ Minimatch.prototype.match = match
+ function match (f, partial) {
+ // console.error("match", f, this.pattern)
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) return false
+ if (this.empty) return f === ""
+
+ if (f === "/" && partial) return true
+
+ var options = this.options
+
+ // windows: need to use /, not \
+ // On other platforms, \ is a valid (albeit bad) filename char.
+ if (platform === "win32") {
+ f = f.split("\\").join("/")
+ }
+
+ // treat the test path as a set of pathparts.
+ f = f.split(slashSplit)
+ if (options.debug) {
+ console.error(this.pattern, "split", f)
+ }
+
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
+
+ var set = this.set
+ // console.error(this.pattern, "set", set)
+
+ for (var i = 0, l = set.length; i < l; i ++) {
+ var pattern = set[i]
+ var hit = this.matchOne(f, pattern, partial)
+ if (hit) {
+ if (options.flipNegate) return true
+ return !this.negate
+ }
+ }
+
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) return false
+ return this.negate
+ }
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+ Minimatch.prototype.matchOne = function (file, pattern, partial) {
+ var options = this.options
+
+ if (options.debug) {
+ console.error("matchOne",
+ { "this": this
+ , file: file
+ , pattern: pattern })
+ }
+
+ if (options.matchBase && pattern.length === 1) {
+ file = path.basename(file.join("/")).split("/")
+ }
+
+ if (options.debug) {
+ console.error("matchOne", file.length, pattern.length)
+ }
+
+ for ( var fi = 0
+ , pi = 0
+ , fl = file.length
+ , pl = pattern.length
+ ; (fi < fl) && (pi < pl)
+ ; fi ++, pi ++ ) {
+
+ if (options.debug) {
+ console.error("matchOne loop")
+ }
+ var p = pattern[pi]
+ , f = file[fi]
+
+ if (options.debug) {
+ console.error(pattern, p, f)
+ }
+
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ if (p === false) return false
+
+ if (p === GLOBSTAR) {
+ if (options.debug)
+ console.error('GLOBSTAR', [pattern, p, f])
+
+ // "**"
+ // a/**/b/**/c would match the following:
+ // a/b/x/y/z/c
+ // a/x/y/z/b/c
+ // a/b/x/b/x/c
+ // a/b/c
+ // To do this, take the rest of the pattern after
+ // the **, and see if it would match the file remainder.
+ // If so, return success.
+ // If not, the ** "swallows" a segment, and try again.
+ // This is recursively awful.
+ //
+ // a/**/b/**/c matching a/b/x/y/z/c
+ // - a matches a
+ // - doublestar
+ // - matchOne(b/x/y/z/c, b/**/c)
+ // - b matches b
+ // - doublestar
+ // - matchOne(x/y/z/c, c) -> no
+ // - matchOne(y/z/c, c) -> no
+ // - matchOne(z/c, c) -> no
+ // - matchOne(c, c) yes, hit
+ var fr = fi
+ , pr = pi + 1
+ if (pr === pl) {
+ if (options.debug)
+ console.error('** at the end')
+ // a ** at the end will just swallow the rest.
+ // We have found a match.
+ // however, it will not swallow /.x, unless
+ // options.dot is set.
+ // . and .. are *never* matched by **, for explosively
+ // exponential reasons.
+ for ( ; fi < fl; fi ++) {
+ if (file[fi] === "." || file[fi] === ".." ||
+ (!options.dot && file[fi].charAt(0) === ".")) return false
+ }
+ return true
+ }
+
+ // ok, let's see if we can swallow whatever we can.
+ WHILE: while (fr < fl) {
+ var swallowee = file[fr]
+
+ if (options.debug) {
+ console.error('\nglobstar while',
+ file, fr, pattern, pr, swallowee)
+ }
+
+ // XXX remove this slice. Just pass the start index.
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ if (options.debug)
+ console.error('globstar found match!', fr, fl, swallowee)
+ // found a match.
+ return true
+ } else {
+ // can't swallow "." or ".." ever.
+ // can only swallow ".foo" when explicitly asked.
+ if (swallowee === "." || swallowee === ".." ||
+ (!options.dot && swallowee.charAt(0) === ".")) {
+ if (options.debug)
+ console.error("dot detected!", file, fr, pattern, pr)
+ break WHILE
+ }
+
+ // ** swallows a segment, and continue.
+ if (options.debug)
+ console.error('globstar swallow a segment, and continue')
+ fr ++
+ }
+ }
+ // no match was found.
+ // However, in partial mode, we can't say this is necessarily over.
+ // If there's more *pattern* left, then
+ if (partial) {
+ // ran out of file
+ // console.error("\n>>> no match, partial?", file, fr, pattern, pr)
+ if (fr === fl) return true
+ }
+ return false
+ }
+
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ var hit
+ if (typeof p === "string") {
+ if (options.nocase) {
+ hit = f.toLowerCase() === p.toLowerCase()
+ } else {
+ hit = f === p
+ }
+ if (options.debug) {
+ console.error("string match", p, f, hit)
+ }
+ } else {
+ hit = f.match(p)
+ if (options.debug) {
+ console.error("pattern match", p, f, hit)
+ }
+ }
+
+ if (!hit) return false
+ }
+
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
+
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true
+ } else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial
+ } else if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ var emptyFileEnd = (fi === fl - 1) && (file[fi] === "")
+ return emptyFileEnd
+ }
+
+ // should be unreachable.
+ throw new Error("wtf?")
+ }
+
+
+// replace stuff like \* with *
+ function globUnescape (s) {
+ return s.replace(/\\(.)/g, "$1")
+ }
+
+
+ function regExpEscape (s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")
+ }
diff --git a/_mint/node_modules/editorconfig/src/lib/ini.d.ts b/_mint/node_modules/editorconfig/src/lib/ini.d.ts
new file mode 100644
index 0000000..fa18568
--- /dev/null
+++ b/_mint/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;
diff --git a/_mint/node_modules/editorconfig/src/lib/ini.js b/_mint/node_modules/editorconfig/src/lib/ini.js
new file mode 100644
index 0000000..d205909
--- /dev/null
+++ b/_mint/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;
© Floofi Systems, Some rights reserved. Powered by cgit.