fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/stylelint/node_modules/balanced-match/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+tidelift: 'npm/balanced-match'
+patreon: juliangruber

node_modules/stylelint/node_modules/balanced-match/LICENSE.md

@@ -0,0 +1,21 @@
+(MIT)
+
+Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+
+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/stylelint/node_modules/balanced-match/README.md

@@ -0,0 +1,97 @@
+# balanced-match
+
+Match balanced string pairs, like `{` and `}` or `<b>` and `</b>`. Supports regular expressions as well!
+
+[![build status](https://secure.travis-ci.org/juliangruber/balanced-match.svg)](http://travis-ci.org/juliangruber/balanced-match)
+[![downloads](https://img.shields.io/npm/dm/balanced-match.svg)](https://www.npmjs.org/package/balanced-match)
+
+[![testling badge](https://ci.testling.com/juliangruber/balanced-match.png)](https://ci.testling.com/juliangruber/balanced-match)
+
+## Example
+
+Get the first matching pair of braces:
+
+```js
+var balanced = require('balanced-match')
+
+console.log(balanced('{', '}', 'pre{in{nested}}post'))
+console.log(balanced('{', '}', 'pre{first}between{second}post'))
+console.log(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre  {   in{nest}   }  post'))
+```
+
+The matches are:
+
+```bash
+$ node example.js
+{ start: 3, end: 14, pre: 'pre', body: 'in{nested}', post: 'post' }
+{ start: 3,
+  end: 9,
+  pre: 'pre',
+  body: 'first',
+  post: 'between{second}post' }
+{ start: 3, end: 17, pre: 'pre', body: 'in{nest}', post: 'post' }
+```
+
+## API
+
+### var m = balanced(a, b, str)
+
+For the first non-nested matching pair of `a` and `b` in `str`, return an
+object with those keys:
+
+- **start** the index of the first match of `a`
+- **end** the index of the matching `b`
+- **pre** the preamble, `a` and `b` not included
+- **body** the match, `a` and `b` not included
+- **post** the postscript, `a` and `b` not included
+
+If there's no match, `undefined` will be returned.
+
+If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `['{', 'a', '']` and `{a}}` will match `['', 'a', '}']`.
+
+### var r = balanced.range(a, b, str)
+
+For the first non-nested matching pair of `a` and `b` in `str`, return an
+array with indexes: `[ <a index>, <b index> ]`.
+
+If there's no match, `undefined` will be returned.
+
+If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `[ 1, 3 ]` and `{a}}` will match `[0, 2]`.
+
+## Installation
+
+With [npm](https://npmjs.org) do:
+
+```bash
+npm install balanced-match
+```
+
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
+## License
+
+(MIT)
+
+Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
+
+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/stylelint/node_modules/balanced-match/index.js

@@ -0,0 +1,64 @@
+'use strict'
+module.exports = balanced
+function balanced (a, b, str) {
+  if (a instanceof RegExp) a = maybeMatch(a, str)
+  if (b instanceof RegExp) b = maybeMatch(b, str)
+
+  const r = range(a, b, str)
+
+  return (
+    r && {
+      start: r[0],
+      end: r[1],
+      pre: str.slice(0, r[0]),
+      body: str.slice(r[0] + a.length, r[1]),
+      post: str.slice(r[1] + b.length)
+    }
+  )
+}
+
+function maybeMatch (reg, str) {
+  const m = str.match(reg)
+  return m ? m[0] : null
+}
+
+balanced.range = range
+function range (a, b, str) {
+  let begs, beg, left, right, result
+  let ai = str.indexOf(a)
+  let bi = str.indexOf(b, ai + 1)
+  let i = ai
+
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi]
+    }
+    begs = []
+    left = str.length
+
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i)
+        ai = str.indexOf(a, i + 1)
+      } else if (begs.length === 1) {
+        result = [begs.pop(), bi]
+      } else {
+        beg = begs.pop()
+        if (beg < left) {
+          left = beg
+          right = bi
+        }
+
+        bi = str.indexOf(b, i + 1)
+      }
+
+      i = ai < bi && ai >= 0 ? ai : bi
+    }
+
+    if (begs.length) {
+      result = [left, right]
+    }
+  }
+
+  return result
+}

node_modules/stylelint/node_modules/balanced-match/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "balanced-match",
+  "description": "Match balanced character pairs, like \"{\" and \"}\"",
+  "version": "2.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/juliangruber/balanced-match.git"
+  },
+  "homepage": "https://github.com/juliangruber/balanced-match",
+  "main": "index.js",
+  "scripts": {
+    "test": "prettier-standard && standard && tape test/test.js",
+    "bench": "matcha test/bench.js",
+    "release": "np"
+  },
+  "devDependencies": {
+    "@c4312/matcha": "^1.3.1",
+    "np": "^7.4.0",
+    "prettier-standard": "^16.4.1",
+    "standard": "^16.0.3",
+    "tape": "^4.6.0"
+  },
+  "keywords": [
+    "match",
+    "regexp",
+    "test",
+    "balanced",
+    "parse"
+  ],
+  "author": {
+    "name": "Julian Gruber",
+    "email": "mail@juliangruber.com",
+    "url": "http://juliangruber.com"
+  },
+  "license": "MIT",
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/20..latest",
+      "firefox/nightly",
+      "chrome/25..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  }
+}

node_modules/stylelint/node_modules/cosmiconfig/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 David Clark
+
+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/stylelint/node_modules/cosmiconfig/README.md

@@ -0,0 +1,581 @@
+# cosmiconfig
+
+[![Build Status](https://img.shields.io/travis/davidtheclark/cosmiconfig/main.svg?label=unix%20build)](https://travis-ci.org/davidtheclark/cosmiconfig) [![Build status](https://img.shields.io/appveyor/ci/davidtheclark/cosmiconfig/main.svg?label=windows%20build)](https://ci.appveyor.com/project/davidtheclark/cosmiconfig/branch/main)
+[![codecov](https://codecov.io/gh/davidtheclark/cosmiconfig/branch/main/graph/badge.svg)](https://codecov.io/gh/davidtheclark/cosmiconfig)
+
+Cosmiconfig searches for and loads configuration for your program.
+
+It features smart defaults based on conventional expectations in the JavaScript ecosystem.
+But it's also flexible enough to search wherever you'd like to search, and load whatever you'd like to load.
+
+By default, Cosmiconfig will start where you tell it to start and search up the directory tree for the following:
+
+- a `package.json` property
+- a JSON or YAML, extensionless "rc file"
+- an "rc file" with the extensions `.json`, `.yaml`, `.yml`, `.js`, or `.cjs`
+- any of the above two inside a `.config` subdirectory
+- a `.config.js` or `.config.cjs` CommonJS module
+
+For example, if your module's name is "myapp", cosmiconfig will search up the directory tree for configuration in the following places:
+
+- a `myapp` property in `package.json`
+- a `.myapprc` file in JSON or YAML format
+- a `.myapprc.json`, `.myapprc.yaml`, `.myapprc.yml`, `.myapprc.js`, or `.myapprc.cjs` file
+- a `myapprc`, `myapprc.json`, `myapprc.yaml`, `myapprc.yml`, `myapprc.js` or `myapprc.cjs` file inside a `.config` subdirectory`
+- a `myapp.config.js` or `myapp.config.cjs` CommonJS module exporting an object
+
+Cosmiconfig continues to search up the directory tree, checking each of these places in each directory, until it finds some acceptable configuration (or hits the home directory).
+
+## Table of contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Result](#result)
+- [Asynchronous API](#asynchronous-api)
+  - [cosmiconfig()](#cosmiconfig-1)
+  - [explorer.search()](#explorersearch)
+  - [explorer.load()](#explorerload)
+  - [explorer.clearLoadCache()](#explorerclearloadcache)
+  - [explorer.clearSearchCache()](#explorerclearsearchcache)
+  - [explorer.clearCaches()](#explorerclearcaches)
+- [Synchronous API](#synchronous-api)
+  - [cosmiconfigSync()](#cosmiconfigsync)
+  - [explorerSync.search()](#explorersyncsearch)
+  - [explorerSync.load()](#explorersyncload)
+  - [explorerSync.clearLoadCache()](#explorersyncclearloadcache)
+  - [explorerSync.clearSearchCache()](#explorersyncclearsearchcache)
+  - [explorerSync.clearCaches()](#explorersyncclearcaches)
+- [cosmiconfigOptions](#cosmiconfigoptions)
+  - [searchPlaces](#searchplaces)
+  - [loaders](#loaders)
+  - [packageProp](#packageprop)
+  - [stopDir](#stopdir)
+  - [cache](#cache)
+  - [transform](#transform)
+  - [ignoreEmptySearchPlaces](#ignoreemptysearchplaces)
+- [Caching](#caching)
+- [Differences from rc](#differences-from-rc)
+- [Contributing & Development](#contributing--development)
+
+## Installation
+
+```
+npm install cosmiconfig
+```
+
+Tested in Node 10+.
+
+## Usage
+
+Create a Cosmiconfig explorer, then either `search` for or directly `load` a configuration file.
+
+```js
+const { cosmiconfig, cosmiconfigSync } = require('cosmiconfig');
+// ...
+const explorer = cosmiconfig(moduleName);
+
+// Search for a configuration by walking up directories.
+// See documentation for search, below.
+explorer.search()
+  .then((result) => {
+    // result.config is the parsed configuration object.
+    // result.filepath is the path to the config file that was found.
+    // result.isEmpty is true if there was nothing to parse in the config file.
+  })
+  .catch((error) => {
+    // Do something constructive.
+  });
+
+// Load a configuration directly when you know where it should be.
+// The result object is the same as for search.
+// See documentation for load, below.
+explorer.load(pathToConfig).then(..);
+
+// You can also search and load synchronously.
+const explorerSync = cosmiconfigSync(moduleName);
+
+const searchedFor = explorerSync.search();
+const loaded = explorerSync.load(pathToConfig);
+```
+
+## Result
+
+The result object you get from `search` or `load` has the following properties:
+
+- **config:** The parsed configuration object. `undefined` if the file is empty.
+- **filepath:** The path to the configuration file that was found.
+- **isEmpty:** `true` if the configuration file is empty. This property will not be present if the configuration file is not empty.
+
+## Asynchronous API
+
+### cosmiconfig()
+
+```js
+const { cosmiconfig } = require('cosmiconfig');
+const explorer = cosmiconfig(moduleName[, cosmiconfigOptions])
+```
+
+Creates a cosmiconfig instance ("explorer") configured according to the arguments, and initializes its caches.
+
+#### moduleName
+
+Type: `string`. **Required.**
+
+Your module name. This is used to create the default [`searchPlaces`] and [`packageProp`].
+
+If your [`searchPlaces`] value will include files, as it does by default (e.g. `${moduleName}rc`), your `moduleName` must consist of characters allowed in filenames. That means you should not copy scoped package names, such as `@my-org/my-package`, directly into `moduleName`.
+
+**[`cosmiconfigOptions`] are documented below.**
+You may not need them, and should first read about the functions you'll use.
+
+### explorer.search()
+
+```js
+explorer.search([searchFrom]).then(result => {..})
+```
+
+Searches for a configuration file. Returns a Promise that resolves with a [result] or with `null`, if no configuration file is found.
+
+You can do the same thing synchronously with [`explorerSync.search()`].
+
+Let's say your module name is `goldengrahams` so you initialized with `const explorer = cosmiconfig('goldengrahams');`.
+Here's how your default [`search()`] will work:
+
+- Starting from `process.cwd()` (or some other directory defined by the `searchFrom` argument to [`search()`]), look for configuration objects in the following places:
+  1. A `goldengrahams` property in a `package.json` file.
+  2. A `.goldengrahamsrc` file with JSON or YAML syntax.
+  3. A `.goldengrahamsrc.json`, `.goldengrahamsrc.yaml`, `.goldengrahamsrc.yml`, `.goldengrahamsrc.js`, or `.goldengrahamsrc.cjs` file.
+  4. A `goldengrahamsrc`, `goldengrahamsrc.json`, `goldengrahamsrc.yaml`, `goldengrahamsrc.yml`, `goldengrahamsrc.js`, or `goldengrahamsrc.cjs` file in the `.config` subdirectory.
+  5. A `goldengrahams.config.js` or `goldengrahams.config.cjs` CommonJS module exporting the object.
+- If none of those searches reveal a configuration object, move up one directory level and try again.
+  So the search continues in `./`, `../`, `../../`, `../../../`, etc., checking the same places in each directory.
+- Continue searching until arriving at your home directory (or some other directory defined by the cosmiconfig option [`stopDir`]).
+- If at any point a parsable configuration is found, the [`search()`] Promise resolves with its [result] \(or, with [`explorerSync.search()`], the [result] is returned).
+- If no configuration object is found, the [`search()`] Promise resolves with `null` (or, with [`explorerSync.search()`], `null` is returned).
+- If a configuration object is found *but is malformed* (causing a parsing error), the [`search()`] Promise rejects with that error (so you should `.catch()` it). (Or, with [`explorerSync.search()`], the error is thrown.)
+
+**If you know exactly where your configuration file should be, you can use [`load()`], instead.**
+
+**The search process is highly customizable.**
+Use the cosmiconfig options [`searchPlaces`] and [`loaders`] to precisely define where you want to look for configurations and how you want to load them.
+
+#### searchFrom
+
+Type: `string`.
+Default: `process.cwd()`.
+
+A filename.
+[`search()`] will start its search here.
+
+If the value is a directory, that's where the search starts.
+If it's a file, the search starts in that file's directory.
+
+### explorer.load()
+
+```js
+explorer.load(loadPath).then(result => {..})
+```
+
+Loads a configuration file. Returns a Promise that resolves with a [result] or rejects with an error (if the file does not exist or cannot be loaded).
+
+Use `load` if you already know where the configuration file is and you just need to load it.
+
+```js
+explorer.load('load/this/file.json'); // Tries to load load/this/file.json.
+```
+
+If you load a `package.json` file, the result will be derived from whatever property is specified as your [`packageProp`].
+
+You can do the same thing synchronously with [`explorerSync.load()`].
+
+### explorer.clearLoadCache()
+
+Clears the cache used in [`load()`].
+
+### explorer.clearSearchCache()
+
+Clears the cache used in [`search()`].
+
+### explorer.clearCaches()
+
+Performs both [`clearLoadCache()`] and [`clearSearchCache()`].
+
+## Synchronous API
+
+### cosmiconfigSync()
+
+```js
+const { cosmiconfigSync } = require('cosmiconfig');
+const explorerSync = cosmiconfigSync(moduleName[, cosmiconfigOptions])
+```
+
+Creates a *synchronous* cosmiconfig instance ("explorerSync") configured according to the arguments, and initializes its caches.
+
+See [`cosmiconfig()`].
+
+### explorerSync.search()
+
+```js
+const result = explorerSync.search([searchFrom]);
+```
+
+Synchronous version of [`explorer.search()`].
+
+Returns a [result] or `null`.
+
+### explorerSync.load()
+
+```js
+const result = explorerSync.load(loadPath);
+```
+
+Synchronous version of [`explorer.load()`].
+
+Returns a [result].
+
+### explorerSync.clearLoadCache()
+
+Clears the cache used in [`load()`].
+
+### explorerSync.clearSearchCache()
+
+Clears the cache used in [`search()`].
+
+### explorerSync.clearCaches()
+
+Performs both [`clearLoadCache()`] and [`clearSearchCache()`].
+
+## cosmiconfigOptions
+
+Type: `Object`.
+
+Possible options are documented below.
+
+### searchPlaces
+
+Type: `Array<string>`.
+Default: See below.
+
+An array of places that [`search()`] will check in each directory as it moves up the directory tree.
+Each place is relative to the directory being searched, and the places are checked in the specified order.
+
+**Default `searchPlaces`:**
+
+```js
+[
+  'package.json',
+  `.${moduleName}rc`,
+  `.${moduleName}rc.json`,
+  `.${moduleName}rc.yaml`,
+  `.${moduleName}rc.yml`,
+  `.${moduleName}rc.js`,
+  `.${moduleName}rc.cjs`,
+  `.config/${moduleName}rc`,
+  `.config/${moduleName}rc.json`,
+  `.config/${moduleName}rc.yaml`,
+  `.config/${moduleName}rc.yml`,
+  `.config/${moduleName}rc.js`,
+  `.config/${moduleName}rc.cjs`,
+  `${moduleName}.config.js`,
+  `${moduleName}.config.cjs`,
+]
+```
+
+Create your own array to search more, fewer, or altogether different places.
+
+Every item in `searchPlaces` needs to have a loader in [`loaders`] that corresponds to its extension.
+(Common extensions are covered by default loaders.)
+Read more about [`loaders`] below.
+
+`package.json` is a special value: When it is included in `searchPlaces`, Cosmiconfig will always parse it as JSON and load a property within it, not the whole file.
+That property is defined with the [`packageProp`] option, and defaults to your module name.
+
+Examples, with a module named `porgy`:
+
+```js
+// Disallow extensions on rc files:
+[
+  'package.json',
+  '.porgyrc',
+  'porgy.config.js'
+]
+
+// ESLint searches for configuration in these places:
+[
+  '.eslintrc.js',
+  '.eslintrc.yaml',
+  '.eslintrc.yml',
+  '.eslintrc.json',
+  '.eslintrc',
+  'package.json'
+]
+
+// Babel looks in fewer places:
+[
+  'package.json',
+  '.babelrc'
+]
+
+// Maybe you want to look for a wide variety of JS flavors:
+[
+  'porgy.config.js',
+  'porgy.config.mjs',
+  'porgy.config.ts',
+  'porgy.config.coffee'
+]
+// ^^ You will need to designate custom loaders to tell
+// Cosmiconfig how to handle these special JS flavors.
+
+// Look within a .config/ subdirectory of every searched directory:
+[
+  'package.json',
+  '.porgyrc',
+  '.config/.porgyrc',
+  '.porgyrc.json',
+  '.config/.porgyrc.json'
+]
+```
+
+### loaders
+
+Type: `Object`.
+Default: See below.
+
+An object that maps extensions to the loader functions responsible for loading and parsing files with those extensions.
+
+Cosmiconfig exposes its default loaders on a named export `defaultLoaders`.
+
+**Default `loaders`:**
+
+```js
+const { defaultLoaders } = require('cosmiconfig');
+
+console.log(Object.entries(defaultLoaders))
+// [
+//   [ '.cjs', [Function: loadJs] ],
+//   [ '.js', [Function: loadJs] ],
+//   [ '.json', [Function: loadJson] ],
+//   [ '.yaml', [Function: loadYaml] ],
+//   [ '.yml', [Function: loadYaml] ],
+//   [ 'noExt', [Function: loadYaml] ]
+// ]
+```
+
+(YAML is a superset of JSON; which means YAML parsers can parse JSON; which is how extensionless files can be either YAML *or* JSON with only one parser.)
+
+**If you provide a `loaders` object, your object will be *merged* with the defaults.**
+So you can override one or two without having to override them all.
+
+**Keys in `loaders`** are extensions (starting with a period), or `noExt` to specify the loader for files *without* extensions, like `.myapprc`.
+
+**Values in `loaders`** are a loader function (described below) whose values are loader functions.
+
+**The most common use case for custom loaders value is to load extensionless `rc` files as strict JSON**, instead of JSON *or* YAML (the default).
+To accomplish that, provide the following `loaders` value:
+
+```js
+{
+  noExt: defaultLoaders['.json']
+}
+```
+
+If you want to load files that are not handled by the loader functions Cosmiconfig exposes, you can write a custom loader function or use one from NPM if it exists.
+
+**Third-party loaders:**
+
+- [cosmiconfig-typescript-loader](https://github.com/codex-/cosmiconfig-typescript-loader)
+
+**Use cases for custom loader function:**
+
+- Allow configuration syntaxes that aren't handled by Cosmiconfig's defaults, like JSON5, INI, or XML.
+- Allow ES2015 modules from `.mjs` configuration files.
+- Parse JS files with Babel before deriving the configuration.
+
+**Custom loader functions** have the following signature:
+
+```js
+// Sync
+(filepath: string, content: string) => Object | null
+
+// Async
+(filepath: string, content: string) => Object | null | Promise<Object | null>
+```
+
+Cosmiconfig reads the file when it checks whether the file exists, so it will provide you with both the file's path and its content.
+Do whatever you need to, and return either a configuration object or `null` (or, for async-only loaders, a Promise that resolves with one of those).
+`null` indicates that no real configuration was found and the search should continue.
+
+A few things to note:
+
+- If you use a custom loader, be aware of whether it's sync or async: you cannot use async customer loaders with the sync API ([`cosmiconfigSync()`]).
+- **Special JS syntax can also be handled by using a `require` hook**, because `defaultLoaders['.js']` just uses `require`.
+  Whether you use custom loaders or a `require` hook is up to you.
+
+Examples:
+
+```js
+// Allow JSON5 syntax:
+{
+  '.json': json5Loader
+}
+
+// Allow a special configuration syntax of your own creation:
+{
+  '.special': specialLoader
+}
+
+// Allow many flavors of JS, using custom loaders:
+{
+  '.mjs': esmLoader,
+  '.ts': typeScriptLoader,
+  '.coffee': coffeeScriptLoader
+}
+
+// Allow many flavors of JS but rely on require hooks:
+{
+  '.mjs': defaultLoaders['.js'],
+  '.ts': defaultLoaders['.js'],
+  '.coffee': defaultLoaders['.js']
+}
+```
+
+### packageProp
+
+Type: `string | Array<string>`.
+Default: `` `${moduleName}` ``.
+
+Name of the property in `package.json` to look for.
+
+Use a period-delimited string or an array of strings to describe a path to nested properties.
+
+For example, the value `'configs.myPackage'` or `['configs', 'myPackage']` will get you the `"myPackage"` value in a `package.json` like this:
+
+```json
+{
+  "configs": {
+    "myPackage": {..}
+  }
+}
+```
+
+If nested property names within the path include periods, you need to use an array of strings. For example, the value `['configs', 'foo.bar', 'baz']` will get you the `"baz"` value in a `package.json` like this:
+
+```json
+{
+  "configs": {
+    "foo.bar": {
+      "baz": {..}
+    }
+  }
+}
+```
+
+If a string includes period but corresponds to a top-level property name, it will not be interpreted as a period-delimited path. For example, the value `'one.two'` will get you the `"three"` value in a `package.json` like this:
+
+```json
+{
+  "one.two": "three",
+  "one": {
+    "two": "four"
+  }
+}
+```
+
+### stopDir
+
+Type: `string`.
+Default: Absolute path to your home directory.
+
+Directory where the search will stop.
+
+### cache
+
+Type: `boolean`.
+Default: `true`.
+
+If `false`, no caches will be used.
+Read more about ["Caching"](#caching) below.
+
+### transform
+
+Type: `(Result) => Promise<Result> | Result`.
+
+A function that transforms the parsed configuration. Receives the [result].
+
+If using [`search()`] or [`load()`] \(which are async), the transform function can return the transformed result or return a Promise that resolves with the transformed result.
+If using `cosmiconfigSync`, [`search()`] or [`load()`], the function must be synchronous and return the transformed result.
+
+The reason you might use this option — instead of simply applying your transform function some other way — is that *the transformed result will be cached*. If your transformation involves additional filesystem I/O or other potentially slow processing, you can use this option to avoid repeating those steps every time a given configuration is searched or loaded.
+
+### ignoreEmptySearchPlaces
+
+Type: `boolean`.
+Default: `true`.
+
+By default, if [`search()`] encounters an empty file (containing nothing but whitespace) in one of the [`searchPlaces`], it will ignore the empty file and move on.
+If you'd like to load empty configuration files, instead, set this option to `false`.
+
+Why might you want to load empty configuration files?
+If you want to throw an error, or if an empty configuration file means something to your program.
+
+## Caching
+
+As of v2, cosmiconfig uses caching to reduce the need for repetitious reading of the filesystem or expensive transforms. Every new cosmiconfig instance (created with `cosmiconfig()`) has its own caches.
+
+To avoid or work around caching, you can do the following:
+
+- Set the `cosmiconfig` option [`cache`] to `false`.
+- Use the cache-clearing methods [`clearLoadCache()`], [`clearSearchCache()`], and [`clearCaches()`].
+- Create separate instances of cosmiconfig (separate "explorers").
+
+## Differences from [rc](https://github.com/dominictarr/rc)
+
+[rc](https://github.com/dominictarr/rc) serves its focused purpose well. cosmiconfig differs in a few key ways — making it more useful for some projects, less useful for others:
+
+- Looks for configuration in some different places: in a `package.json` property, an rc file, a `.config.js` file, and rc files with extensions.
+- Built-in support for JSON, YAML, and CommonJS formats.
+- Stops at the first configuration found, instead of finding all that can be found up the directory tree and merging them automatically.
+- Options.
+- Asynchronous by default (though can be run synchronously).
+
+## Contributing & Development
+
+Please note that this project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms.
+
+And please do participate!
+
+[result]: #result
+
+[`load()`]: #explorerload
+
+[`search()`]: #explorersearch
+
+[`clearloadcache()`]: #explorerclearloadcache
+
+[`clearsearchcache()`]: #explorerclearsearchcache
+
+[`cosmiconfig()`]: #cosmiconfig
+
+[`cosmiconfigSync()`]: #cosmiconfigsync
+
+[`clearcaches()`]: #explorerclearcaches
+
+[`packageprop`]: #packageprop
+
+[`cache`]: #cache
+
+[`stopdir`]: #stopdir
+
+[`searchplaces`]: #searchplaces
+
+[`loaders`]: #loaders
+
+[`cosmiconfigoptions`]: #cosmiconfigoptions
+
+[`explorerSync.search()`]: #explorersyncsearch
+
+[`explorerSync.load()`]: #explorersyncload
+
+[`explorer.search()`]: #explorersearch
+
+[`explorer.load()`]: #explorerload

node_modules/stylelint/node_modules/cosmiconfig/dist/Explorer.d.ts

@@ -0,0 +1,14 @@
+import { ExplorerBase } from './ExplorerBase';
+import { CosmiconfigResult, ExplorerOptions } from './types';
+declare class Explorer extends ExplorerBase<ExplorerOptions> {
+    constructor(options: ExplorerOptions);
+    search(searchFrom?: string): Promise<CosmiconfigResult>;
+    private searchFromDirectory;
+    private searchDirectory;
+    private loadSearchPlace;
+    private loadFileContent;
+    private createCosmiconfigResult;
+    load(filepath: string): Promise<CosmiconfigResult>;
+}
+export { Explorer };
+//# sourceMappingURL=Explorer.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/Explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Explorer.d.ts","sourceRoot":"","sources":["../src/Explorer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAqB,MAAM,SAAS,CAAC;AAEhF,cAAM,QAAS,SAAQ,YAAY,CAAC,eAAe,CAAC;gBAC/B,OAAO,EAAE,eAAe;IAI9B,MAAM,CACjB,UAAU,GAAE,MAAsB,GACjC,OAAO,CAAC,iBAAiB,CAAC;YAOf,mBAAmB;YAuBnB,eAAe;YAaf,eAAe;YAYf,eAAe;YAef,uBAAuB;IAUxB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAyBhE;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/Explorer.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Explorer = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _ExplorerBase = require("./ExplorerBase");
+
+var _readFile = require("./readFile");
+
+var _cacheWrapper = require("./cacheWrapper");
+
+var _getDirectory = require("./getDirectory");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Explorer extends _ExplorerBase.ExplorerBase {
+  constructor(options) {
+    super(options);
+  }
+
+  async search(searchFrom = process.cwd()) {
+    const startDirectory = await (0, _getDirectory.getDirectory)(searchFrom);
+    const result = await this.searchFromDirectory(startDirectory);
+    return result;
+  }
+
+  async searchFromDirectory(dir) {
+    const absoluteDir = _path.default.resolve(process.cwd(), dir);
+
+    const run = async () => {
+      const result = await this.searchDirectory(absoluteDir);
+      const nextDir = this.nextDirectoryToSearch(absoluteDir, result);
+
+      if (nextDir) {
+        return this.searchFromDirectory(nextDir);
+      }
+
+      const transformResult = await this.config.transform(result);
+      return transformResult;
+    };
+
+    if (this.searchCache) {
+      return (0, _cacheWrapper.cacheWrapper)(this.searchCache, absoluteDir, run);
+    }
+
+    return run();
+  }
+
+  async searchDirectory(dir) {
+    for await (const place of this.config.searchPlaces) {
+      const placeResult = await this.loadSearchPlace(dir, place);
+
+      if (this.shouldSearchStopWithResult(placeResult) === true) {
+        return placeResult;
+      }
+    } // config not found
+
+
+    return null;
+  }
+
+  async loadSearchPlace(dir, place) {
+    const filepath = _path.default.join(dir, place);
+
+    const fileContents = await (0, _readFile.readFile)(filepath);
+    const result = await this.createCosmiconfigResult(filepath, fileContents);
+    return result;
+  }
+
+  async loadFileContent(filepath, content) {
+    if (content === null) {
+      return null;
+    }
+
+    if (content.trim() === '') {
+      return undefined;
+    }
+
+    const loader = this.getLoaderEntryForFile(filepath);
+    const loaderResult = await loader(filepath, content);
+    return loaderResult;
+  }
+
+  async createCosmiconfigResult(filepath, content) {
+    const fileContent = await this.loadFileContent(filepath, content);
+    const result = this.loadedContentToCosmiconfigResult(filepath, fileContent);
+    return result;
+  }
+
+  async load(filepath) {
+    this.validateFilePath(filepath);
+
+    const absoluteFilePath = _path.default.resolve(process.cwd(), filepath);
+
+    const runLoad = async () => {
+      const fileContents = await (0, _readFile.readFile)(absoluteFilePath, {
+        throwNotFound: true
+      });
+      const result = await this.createCosmiconfigResult(absoluteFilePath, fileContents);
+      const transformResult = await this.config.transform(result);
+      return transformResult;
+    };
+
+    if (this.loadCache) {
+      return (0, _cacheWrapper.cacheWrapper)(this.loadCache, absoluteFilePath, runLoad);
+    }
+
+    return runLoad();
+  }
+
+}
+
+exports.Explorer = Explorer;
+//# sourceMappingURL=Explorer.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/ExplorerBase.d.ts

@@ -0,0 +1,21 @@
+import { CosmiconfigResult, ExplorerOptions, ExplorerOptionsSync, Cache, LoadedFileContent } from './types';
+import { Loader } from './index';
+declare class ExplorerBase<T extends ExplorerOptions | ExplorerOptionsSync> {
+    protected readonly loadCache?: Cache;
+    protected readonly searchCache?: Cache;
+    protected readonly config: T;
+    constructor(options: T);
+    clearLoadCache(): void;
+    clearSearchCache(): void;
+    clearCaches(): void;
+    private validateConfig;
+    protected shouldSearchStopWithResult(result: CosmiconfigResult): boolean;
+    protected nextDirectoryToSearch(currentDir: string, currentResult: CosmiconfigResult): string | null;
+    private loadPackageProp;
+    protected getLoaderEntryForFile(filepath: string): Loader;
+    protected loadedContentToCosmiconfigResult(filepath: string, loadedContent: LoadedFileContent): CosmiconfigResult;
+    protected validateFilePath(filepath: string): void;
+}
+declare function getExtensionDescription(filepath: string): string;
+export { ExplorerBase, getExtensionDescription };
+//# sourceMappingURL=ExplorerBase.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/ExplorerBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExplorerBase.d.ts","sourceRoot":"","sources":["../src/ExplorerBase.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,KAAK,EACL,iBAAiB,EAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC,cAAM,YAAY,CAAC,CAAC,SAAS,eAAe,GAAG,mBAAmB;IAChE,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC;IACrC,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IACvC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;gBAEV,OAAO,EAAE,CAAC;IAUtB,cAAc,IAAI,IAAI;IAMtB,gBAAgB,IAAI,IAAI;IAMxB,WAAW,IAAI,IAAI;IAK1B,OAAO,CAAC,cAAc;IAwBtB,SAAS,CAAC,0BAA0B,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO;IAMxE,SAAS,CAAC,qBAAqB,CAC7B,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,iBAAiB,GAC/B,MAAM,GAAG,IAAI;IAWhB,OAAO,CAAC,eAAe;IASvB,SAAS,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAmBzD,SAAS,CAAC,gCAAgC,CACxC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,iBAAiB,GAC/B,iBAAiB;IAUpB,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAKnD;AAMD,iBAAS,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/ExplorerBase.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExplorerBase = void 0;
+exports.getExtensionDescription = getExtensionDescription;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _loaders = require("./loaders");
+
+var _getPropertyByPath = require("./getPropertyByPath");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ExplorerBase {
+  constructor(options) {
+    if (options.cache === true) {
+      this.loadCache = new Map();
+      this.searchCache = new Map();
+    }
+
+    this.config = options;
+    this.validateConfig();
+  }
+
+  clearLoadCache() {
+    if (this.loadCache) {
+      this.loadCache.clear();
+    }
+  }
+
+  clearSearchCache() {
+    if (this.searchCache) {
+      this.searchCache.clear();
+    }
+  }
+
+  clearCaches() {
+    this.clearLoadCache();
+    this.clearSearchCache();
+  }
+
+  validateConfig() {
+    const config = this.config;
+    config.searchPlaces.forEach(place => {
+      const loaderKey = _path.default.extname(place) || 'noExt';
+      const loader = config.loaders[loaderKey];
+
+      if (!loader) {
+        throw new Error(`No loader specified for ${getExtensionDescription(place)}, so searchPlaces item "${place}" is invalid`);
+      }
+
+      if (typeof loader !== 'function') {
+        throw new Error(`loader for ${getExtensionDescription(place)} is not a function (type provided: "${typeof loader}"), so searchPlaces item "${place}" is invalid`);
+      }
+    });
+  }
+
+  shouldSearchStopWithResult(result) {
+    if (result === null) return false;
+    if (result.isEmpty && this.config.ignoreEmptySearchPlaces) return false;
+    return true;
+  }
+
+  nextDirectoryToSearch(currentDir, currentResult) {
+    if (this.shouldSearchStopWithResult(currentResult)) {
+      return null;
+    }
+
+    const nextDir = nextDirUp(currentDir);
+
+    if (nextDir === currentDir || currentDir === this.config.stopDir) {
+      return null;
+    }
+
+    return nextDir;
+  }
+
+  loadPackageProp(filepath, content) {
+    const parsedContent = _loaders.loaders.loadJson(filepath, content);
+
+    const packagePropValue = (0, _getPropertyByPath.getPropertyByPath)(parsedContent, this.config.packageProp);
+    return packagePropValue || null;
+  }
+
+  getLoaderEntryForFile(filepath) {
+    if (_path.default.basename(filepath) === 'package.json') {
+      const loader = this.loadPackageProp.bind(this);
+      return loader;
+    }
+
+    const loaderKey = _path.default.extname(filepath) || 'noExt';
+    const loader = this.config.loaders[loaderKey];
+
+    if (!loader) {
+      throw new Error(`No loader specified for ${getExtensionDescription(filepath)}`);
+    }
+
+    return loader;
+  }
+
+  loadedContentToCosmiconfigResult(filepath, loadedContent) {
+    if (loadedContent === null) {
+      return null;
+    }
+
+    if (loadedContent === undefined) {
+      return {
+        filepath,
+        config: undefined,
+        isEmpty: true
+      };
+    }
+
+    return {
+      config: loadedContent,
+      filepath
+    };
+  }
+
+  validateFilePath(filepath) {
+    if (!filepath) {
+      throw new Error('load must pass a non-empty string');
+    }
+  }
+
+}
+
+exports.ExplorerBase = ExplorerBase;
+
+function nextDirUp(dir) {
+  return _path.default.dirname(dir);
+}
+
+function getExtensionDescription(filepath) {
+  const ext = _path.default.extname(filepath);
+
+  return ext ? `extension "${ext}"` : 'files without extensions';
+}
+//# sourceMappingURL=ExplorerBase.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/ExplorerSync.d.ts

@@ -0,0 +1,14 @@
+import { ExplorerBase } from './ExplorerBase';
+import { CosmiconfigResult, ExplorerOptionsSync } from './types';
+declare class ExplorerSync extends ExplorerBase<ExplorerOptionsSync> {
+    constructor(options: ExplorerOptionsSync);
+    searchSync(searchFrom?: string): CosmiconfigResult;
+    private searchFromDirectorySync;
+    private searchDirectorySync;
+    private loadSearchPlaceSync;
+    private loadFileContentSync;
+    private createCosmiconfigResultSync;
+    loadSync(filepath: string): CosmiconfigResult;
+}
+export { ExplorerSync };
+//# sourceMappingURL=ExplorerSync.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/ExplorerSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExplorerSync.d.ts","sourceRoot":"","sources":["../src/ExplorerSync.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EAEpB,MAAM,SAAS,CAAC;AAEjB,cAAM,YAAa,SAAQ,YAAY,CAAC,mBAAmB,CAAC;gBACvC,OAAO,EAAE,mBAAmB;IAIxC,UAAU,CAAC,UAAU,GAAE,MAAsB,GAAG,iBAAiB;IAOxE,OAAO,CAAC,uBAAuB;IAuB/B,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,2BAA2B;IAU5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB;CAsBrD;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/ExplorerSync.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExplorerSync = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _ExplorerBase = require("./ExplorerBase");
+
+var _readFile = require("./readFile");
+
+var _cacheWrapper = require("./cacheWrapper");
+
+var _getDirectory = require("./getDirectory");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ExplorerSync extends _ExplorerBase.ExplorerBase {
+  constructor(options) {
+    super(options);
+  }
+
+  searchSync(searchFrom = process.cwd()) {
+    const startDirectory = (0, _getDirectory.getDirectorySync)(searchFrom);
+    const result = this.searchFromDirectorySync(startDirectory);
+    return result;
+  }
+
+  searchFromDirectorySync(dir) {
+    const absoluteDir = _path.default.resolve(process.cwd(), dir);
+
+    const run = () => {
+      const result = this.searchDirectorySync(absoluteDir);
+      const nextDir = this.nextDirectoryToSearch(absoluteDir, result);
+
+      if (nextDir) {
+        return this.searchFromDirectorySync(nextDir);
+      }
+
+      const transformResult = this.config.transform(result);
+      return transformResult;
+    };
+
+    if (this.searchCache) {
+      return (0, _cacheWrapper.cacheWrapperSync)(this.searchCache, absoluteDir, run);
+    }
+
+    return run();
+  }
+
+  searchDirectorySync(dir) {
+    for (const place of this.config.searchPlaces) {
+      const placeResult = this.loadSearchPlaceSync(dir, place);
+
+      if (this.shouldSearchStopWithResult(placeResult) === true) {
+        return placeResult;
+      }
+    } // config not found
+
+
+    return null;
+  }
+
+  loadSearchPlaceSync(dir, place) {
+    const filepath = _path.default.join(dir, place);
+
+    const content = (0, _readFile.readFileSync)(filepath);
+    const result = this.createCosmiconfigResultSync(filepath, content);
+    return result;
+  }
+
+  loadFileContentSync(filepath, content) {
+    if (content === null) {
+      return null;
+    }
+
+    if (content.trim() === '') {
+      return undefined;
+    }
+
+    const loader = this.getLoaderEntryForFile(filepath);
+    const loaderResult = loader(filepath, content);
+    return loaderResult;
+  }
+
+  createCosmiconfigResultSync(filepath, content) {
+    const fileContent = this.loadFileContentSync(filepath, content);
+    const result = this.loadedContentToCosmiconfigResult(filepath, fileContent);
+    return result;
+  }
+
+  loadSync(filepath) {
+    this.validateFilePath(filepath);
+
+    const absoluteFilePath = _path.default.resolve(process.cwd(), filepath);
+
+    const runLoadSync = () => {
+      const content = (0, _readFile.readFileSync)(absoluteFilePath, {
+        throwNotFound: true
+      });
+      const cosmiconfigResult = this.createCosmiconfigResultSync(absoluteFilePath, content);
+      const transformResult = this.config.transform(cosmiconfigResult);
+      return transformResult;
+    };
+
+    if (this.loadCache) {
+      return (0, _cacheWrapper.cacheWrapperSync)(this.loadCache, absoluteFilePath, runLoadSync);
+    }
+
+    return runLoadSync();
+  }
+
+}
+
+exports.ExplorerSync = ExplorerSync;
+//# sourceMappingURL=ExplorerSync.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/cacheWrapper.d.ts

@@ -0,0 +1,5 @@
+import { Cache, CosmiconfigResult } from './types';
+declare function cacheWrapper(cache: Cache, key: string, fn: () => Promise<CosmiconfigResult>): Promise<CosmiconfigResult>;
+declare function cacheWrapperSync(cache: Cache, key: string, fn: () => CosmiconfigResult): CosmiconfigResult;
+export { cacheWrapper, cacheWrapperSync };
+//# sourceMappingURL=cacheWrapper.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/cacheWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheWrapper.d.ts","sourceRoot":"","sources":["../src/cacheWrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEnD,iBAAe,YAAY,CACzB,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,OAAO,CAAC,iBAAiB,CAAC,GACnC,OAAO,CAAC,iBAAiB,CAAC,CAS5B;AAED,iBAAS,gBAAgB,CACvB,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,iBAAiB,GAC1B,iBAAiB,CASnB;AAED,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/cacheWrapper.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cacheWrapper = cacheWrapper;
+exports.cacheWrapperSync = cacheWrapperSync;
+
+async function cacheWrapper(cache, key, fn) {
+  const cached = cache.get(key);
+
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const result = await fn();
+  cache.set(key, result);
+  return result;
+}
+
+function cacheWrapperSync(cache, key, fn) {
+  const cached = cache.get(key);
+
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const result = fn();
+  cache.set(key, result);
+  return result;
+}
+//# sourceMappingURL=cacheWrapper.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/cacheWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cacheWrapper.ts"],"names":["cacheWrapper","cache","key","fn","cached","get","undefined","result","set","cacheWrapperSync"],"mappings":";;;;;;;;AAEA,eAAeA,YAAf,CACEC,KADF,EAEEC,GAFF,EAGEC,EAHF,EAI8B;AAC5B,QAAMC,MAAM,GAAGH,KAAK,CAACI,GAAN,CAAUH,GAAV,CAAf;;AACA,MAAIE,MAAM,KAAKE,SAAf,EAA0B;AACxB,WAAOF,MAAP;AACD;;AAED,QAAMG,MAAM,GAAG,MAAMJ,EAAE,EAAvB;AACAF,EAAAA,KAAK,CAACO,GAAN,CAAUN,GAAV,EAAeK,MAAf;AACA,SAAOA,MAAP;AACD;;AAED,SAASE,gBAAT,CACER,KADF,EAEEC,GAFF,EAGEC,EAHF,EAIqB;AACnB,QAAMC,MAAM,GAAGH,KAAK,CAACI,GAAN,CAAUH,GAAV,CAAf;;AACA,MAAIE,MAAM,KAAKE,SAAf,EAA0B;AACxB,WAAOF,MAAP;AACD;;AAED,QAAMG,MAAM,GAAGJ,EAAE,EAAjB;AACAF,EAAAA,KAAK,CAACO,GAAN,CAAUN,GAAV,EAAeK,MAAf;AACA,SAAOA,MAAP;AACD","sourcesContent":["import { Cache, CosmiconfigResult } from './types';\n\nasync function cacheWrapper(\n  cache: Cache,\n  key: string,\n  fn: () => Promise<CosmiconfigResult>,\n): Promise<CosmiconfigResult> {\n  const cached = cache.get(key);\n  if (cached !== undefined) {\n    return cached;\n  }\n\n  const result = await fn();\n  cache.set(key, result);\n  return result;\n}\n\nfunction cacheWrapperSync(\n  cache: Cache,\n  key: string,\n  fn: () => CosmiconfigResult,\n): CosmiconfigResult {\n  const cached = cache.get(key);\n  if (cached !== undefined) {\n    return cached;\n  }\n\n  const result = fn();\n  cache.set(key, result);\n  return result;\n}\n\nexport { cacheWrapper, cacheWrapperSync };\n"],"file":"cacheWrapper.js"}

node_modules/stylelint/node_modules/cosmiconfig/dist/getDirectory.d.ts

@@ -0,0 +1,4 @@
+declare function getDirectory(filepath: string): Promise<string>;
+declare function getDirectorySync(filepath: string): string;
+export { getDirectory, getDirectorySync };
+//# sourceMappingURL=getDirectory.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/getDirectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDirectory.d.ts","sourceRoot":"","sources":["../src/getDirectory.ts"],"names":[],"mappings":"AAGA,iBAAe,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAU7D;AAED,iBAAS,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUlD;AAED,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/getDirectory.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDirectory = getDirectory;
+exports.getDirectorySync = getDirectorySync;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _pathType = require("path-type");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function getDirectory(filepath) {
+  const filePathIsDirectory = await (0, _pathType.isDirectory)(filepath);
+
+  if (filePathIsDirectory === true) {
+    return filepath;
+  }
+
+  const directory = _path.default.dirname(filepath);
+
+  return directory;
+}
+
+function getDirectorySync(filepath) {
+  const filePathIsDirectory = (0, _pathType.isDirectorySync)(filepath);
+
+  if (filePathIsDirectory === true) {
+    return filepath;
+  }
+
+  const directory = _path.default.dirname(filepath);
+
+  return directory;
+}
+//# sourceMappingURL=getDirectory.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/getDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/getDirectory.ts"],"names":["getDirectory","filepath","filePathIsDirectory","directory","path","dirname","getDirectorySync"],"mappings":";;;;;;;;AAAA;;AACA;;;;AAEA,eAAeA,YAAf,CAA4BC,QAA5B,EAA+D;AAC7D,QAAMC,mBAAmB,GAAG,MAAM,2BAAYD,QAAZ,CAAlC;;AAEA,MAAIC,mBAAmB,KAAK,IAA5B,EAAkC;AAChC,WAAOD,QAAP;AACD;;AAED,QAAME,SAAS,GAAGC,cAAKC,OAAL,CAAaJ,QAAb,CAAlB;;AAEA,SAAOE,SAAP;AACD;;AAED,SAASG,gBAAT,CAA0BL,QAA1B,EAAoD;AAClD,QAAMC,mBAAmB,GAAG,+BAAgBD,QAAhB,CAA5B;;AAEA,MAAIC,mBAAmB,KAAK,IAA5B,EAAkC;AAChC,WAAOD,QAAP;AACD;;AAED,QAAME,SAAS,GAAGC,cAAKC,OAAL,CAAaJ,QAAb,CAAlB;;AAEA,SAAOE,SAAP;AACD","sourcesContent":["import path from 'path';\nimport { isDirectory, isDirectorySync } from 'path-type';\n\nasync function getDirectory(filepath: string): Promise<string> {\n  const filePathIsDirectory = await isDirectory(filepath);\n\n  if (filePathIsDirectory === true) {\n    return filepath;\n  }\n\n  const directory = path.dirname(filepath);\n\n  return directory;\n}\n\nfunction getDirectorySync(filepath: string): string {\n  const filePathIsDirectory = isDirectorySync(filepath);\n\n  if (filePathIsDirectory === true) {\n    return filepath;\n  }\n\n  const directory = path.dirname(filepath);\n\n  return directory;\n}\n\nexport { getDirectory, getDirectorySync };\n"],"file":"getDirectory.js"}

node_modules/stylelint/node_modules/cosmiconfig/dist/getPropertyByPath.d.ts

@@ -0,0 +1,5 @@
+declare function getPropertyByPath(source: {
+    [key: string]: unknown;
+}, path: string | Array<string>): unknown;
+export { getPropertyByPath };
+//# sourceMappingURL=getPropertyByPath.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/getPropertyByPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPropertyByPath.d.ts","sourceRoot":"","sources":["../src/getPropertyByPath.ts"],"names":[],"mappings":"AAKA,iBAAS,iBAAiB,CACxB,MAAM,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAClC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAC3B,OAAO,CAgBT;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/getPropertyByPath.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPropertyByPath = getPropertyByPath;
+
+// Resolves property names or property paths defined with period-delimited
+// strings or arrays of strings. Property names that are found on the source
+// object are used directly (even if they include a period).
+// Nested property names that include periods, within a path, are only
+// understood in array paths.
+function getPropertyByPath(source, path) {
+  if (typeof path === 'string' && Object.prototype.hasOwnProperty.call(source, path)) {
+    return source[path];
+  }
+
+  const parsedPath = typeof path === 'string' ? path.split('.') : path; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  return parsedPath.reduce((previous, key) => {
+    if (previous === undefined) {
+      return previous;
+    }
+
+    return previous[key];
+  }, source);
+}
+//# sourceMappingURL=getPropertyByPath.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/getPropertyByPath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/getPropertyByPath.ts"],"names":["getPropertyByPath","source","path","Object","prototype","hasOwnProperty","call","parsedPath","split","reduce","previous","key","undefined"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA,SAASA,iBAAT,CACEC,MADF,EAEEC,IAFF,EAGW;AACT,MACE,OAAOA,IAAP,KAAgB,QAAhB,IACAC,MAAM,CAACC,SAAP,CAAiBC,cAAjB,CAAgCC,IAAhC,CAAqCL,MAArC,EAA6CC,IAA7C,CAFF,EAGE;AACA,WAAOD,MAAM,CAACC,IAAD,CAAb;AACD;;AAED,QAAMK,UAAU,GAAG,OAAOL,IAAP,KAAgB,QAAhB,GAA2BA,IAAI,CAACM,KAAL,CAAW,GAAX,CAA3B,GAA6CN,IAAhE,CARS,CAST;;AACA,SAAOK,UAAU,CAACE,MAAX,CAAkB,CAACC,QAAD,EAAgBC,GAAhB,KAAiC;AACxD,QAAID,QAAQ,KAAKE,SAAjB,EAA4B;AAC1B,aAAOF,QAAP;AACD;;AACD,WAAOA,QAAQ,CAACC,GAAD,CAAf;AACD,GALM,EAKJV,MALI,CAAP;AAMD","sourcesContent":["// Resolves property names or property paths defined with period-delimited\n// strings or arrays of strings. Property names that are found on the source\n// object are used directly (even if they include a period).\n// Nested property names that include periods, within a path, are only\n// understood in array paths.\nfunction getPropertyByPath(\n  source: { [key: string]: unknown },\n  path: string | Array<string>,\n): unknown {\n  if (\n    typeof path === 'string' &&\n    Object.prototype.hasOwnProperty.call(source, path)\n  ) {\n    return source[path];\n  }\n\n  const parsedPath = typeof path === 'string' ? path.split('.') : path;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return parsedPath.reduce((previous: any, key): unknown => {\n    if (previous === undefined) {\n      return previous;\n    }\n    return previous[key];\n  }, source);\n}\n\nexport { getPropertyByPath };\n"],"file":"getPropertyByPath.js"}

node_modules/stylelint/node_modules/cosmiconfig/dist/index.d.ts

@@ -0,0 +1,45 @@
+import { Config, CosmiconfigResult, Loaders, LoadersSync } from './types';
+declare type LoaderResult = Config | null;
+export declare type Loader = ((filepath: string, content: string) => Promise<LoaderResult>) | LoaderSync;
+export declare type LoaderSync = (filepath: string, content: string) => LoaderResult;
+export declare type Transform = ((CosmiconfigResult: CosmiconfigResult) => Promise<CosmiconfigResult>) | TransformSync;
+export declare type TransformSync = (CosmiconfigResult: CosmiconfigResult) => CosmiconfigResult;
+interface OptionsBase {
+    packageProp?: string | Array<string>;
+    searchPlaces?: Array<string>;
+    ignoreEmptySearchPlaces?: boolean;
+    stopDir?: string;
+    cache?: boolean;
+}
+export interface Options extends OptionsBase {
+    loaders?: Loaders;
+    transform?: Transform;
+}
+export interface OptionsSync extends OptionsBase {
+    loaders?: LoadersSync;
+    transform?: TransformSync;
+}
+declare function cosmiconfig(moduleName: string, options?: Options): {
+    readonly search: (searchFrom?: string) => Promise<CosmiconfigResult>;
+    readonly load: (filepath: string) => Promise<CosmiconfigResult>;
+    readonly clearLoadCache: () => void;
+    readonly clearSearchCache: () => void;
+    readonly clearCaches: () => void;
+};
+declare function cosmiconfigSync(moduleName: string, options?: OptionsSync): {
+    readonly search: (searchFrom?: string) => CosmiconfigResult;
+    readonly load: (filepath: string) => CosmiconfigResult;
+    readonly clearLoadCache: () => void;
+    readonly clearSearchCache: () => void;
+    readonly clearCaches: () => void;
+};
+declare const defaultLoaders: Readonly<{
+    readonly '.cjs': LoaderSync;
+    readonly '.js': LoaderSync;
+    readonly '.json': LoaderSync;
+    readonly '.yaml': LoaderSync;
+    readonly '.yml': LoaderSync;
+    readonly noExt: LoaderSync;
+}>;
+export { cosmiconfig, cosmiconfigSync, defaultLoaders };
+//# sourceMappingURL=index.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,MAAM,EACN,iBAAiB,EAGjB,OAAO,EACP,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,aAAK,YAAY,GAAG,MAAM,GAAG,IAAI,CAAC;AAClC,oBAAY,MAAM,GACd,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC,GAC9D,UAAU,CAAC;AACf,oBAAY,UAAU,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,YAAY,CAAC;AAE7E,oBAAY,SAAS,GACjB,CAAC,CAAC,iBAAiB,EAAE,iBAAiB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC,GACtE,aAAa,CAAC;AAElB,oBAAY,aAAa,GAAG,CAC1B,iBAAiB,EAAE,iBAAiB,KACjC,iBAAiB,CAAC;AAEvB,UAAU,WAAW;IACnB,WAAW,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,OAAQ,SAAQ,WAAW;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAGD,iBAAS,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,OAAY;;;;;;EAe7D;AAGD,iBAAS,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB;;;;;;EAerE;AAGD,QAAA,MAAM,cAAc;;;;;;;EAOT,CAAC;AAwDZ,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cosmiconfig = cosmiconfig;
+exports.cosmiconfigSync = cosmiconfigSync;
+exports.defaultLoaders = void 0;
+
+var _os = _interopRequireDefault(require("os"));
+
+var _Explorer = require("./Explorer");
+
+var _ExplorerSync = require("./ExplorerSync");
+
+var _loaders = require("./loaders");
+
+var _types = require("./types");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function cosmiconfig(moduleName, options = {}) {
+  const normalizedOptions = normalizeOptions(moduleName, options);
+  const explorer = new _Explorer.Explorer(normalizedOptions);
+  return {
+    search: explorer.search.bind(explorer),
+    load: explorer.load.bind(explorer),
+    clearLoadCache: explorer.clearLoadCache.bind(explorer),
+    clearSearchCache: explorer.clearSearchCache.bind(explorer),
+    clearCaches: explorer.clearCaches.bind(explorer)
+  };
+} // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+
+
+function cosmiconfigSync(moduleName, options = {}) {
+  const normalizedOptions = normalizeOptions(moduleName, options);
+  const explorerSync = new _ExplorerSync.ExplorerSync(normalizedOptions);
+  return {
+    search: explorerSync.searchSync.bind(explorerSync),
+    load: explorerSync.loadSync.bind(explorerSync),
+    clearLoadCache: explorerSync.clearLoadCache.bind(explorerSync),
+    clearSearchCache: explorerSync.clearSearchCache.bind(explorerSync),
+    clearCaches: explorerSync.clearCaches.bind(explorerSync)
+  };
+} // do not allow mutation of default loaders. Make sure it is set inside options
+
+
+const defaultLoaders = Object.freeze({
+  '.cjs': _loaders.loaders.loadJs,
+  '.js': _loaders.loaders.loadJs,
+  '.json': _loaders.loaders.loadJson,
+  '.yaml': _loaders.loaders.loadYaml,
+  '.yml': _loaders.loaders.loadYaml,
+  noExt: _loaders.loaders.loadYaml
+});
+exports.defaultLoaders = defaultLoaders;
+
+const identity = function identity(x) {
+  return x;
+};
+
+function normalizeOptions(moduleName, options) {
+  const defaults = {
+    packageProp: moduleName,
+    searchPlaces: ['package.json', `.${moduleName}rc`, `.${moduleName}rc.json`, `.${moduleName}rc.yaml`, `.${moduleName}rc.yml`, `.${moduleName}rc.js`, `.${moduleName}rc.cjs`, `.config/${moduleName}rc`, `.config/${moduleName}rc.json`, `.config/${moduleName}rc.yaml`, `.config/${moduleName}rc.yml`, `.config/${moduleName}rc.js`, `.config/${moduleName}rc.cjs`, `${moduleName}.config.js`, `${moduleName}.config.cjs`],
+    ignoreEmptySearchPlaces: true,
+    stopDir: _os.default.homedir(),
+    cache: true,
+    transform: identity,
+    loaders: defaultLoaders
+  };
+  const normalizedOptions = { ...defaults,
+    ...options,
+    loaders: { ...defaults.loaders,
+      ...options.loaders
+    }
+  };
+  return normalizedOptions;
+}
+//# sourceMappingURL=index.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/loaders.d.ts

@@ -0,0 +1,4 @@
+import { LoadersSync } from './types';
+declare const loaders: LoadersSync;
+export { loaders };
+//# sourceMappingURL=loaders.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loaders.d.ts","sourceRoot":"","sources":["../src/loaders.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA0CtC,QAAA,MAAM,OAAO,EAAE,WAA4C,CAAC;AAE5D,OAAO,EAAE,OAAO,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/loaders.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loaders = void 0;
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+let importFresh;
+
+const loadJs = function loadJs(filepath) {
+  if (importFresh === undefined) {
+    importFresh = require('import-fresh');
+  }
+
+  const result = importFresh(filepath);
+  return result;
+};
+
+let parseJson;
+
+const loadJson = function loadJson(filepath, content) {
+  if (parseJson === undefined) {
+    parseJson = require('parse-json');
+  }
+
+  try {
+    const result = parseJson(content);
+    return result;
+  } catch (error) {
+    error.message = `JSON Error in ${filepath}:\n${error.message}`;
+    throw error;
+  }
+};
+
+let yaml;
+
+const loadYaml = function loadYaml(filepath, content) {
+  if (yaml === undefined) {
+    yaml = require('yaml');
+  }
+
+  try {
+    const result = yaml.parse(content, {
+      prettyErrors: true
+    });
+    return result;
+  } catch (error) {
+    error.message = `YAML Error in ${filepath}:\n${error.message}`;
+    throw error;
+  }
+};
+
+const loaders = {
+  loadJs,
+  loadJson,
+  loadYaml
+};
+exports.loaders = loaders;
+//# sourceMappingURL=loaders.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/loaders.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/loaders.ts"],"names":["importFresh","loadJs","filepath","undefined","require","result","parseJson","loadJson","content","error","message","yaml","loadYaml","parse","prettyErrors","loaders"],"mappings":";;;;;;;AAAA;AAQA,IAAIA,WAAJ;;AACA,MAAMC,MAAkB,GAAG,SAASA,MAAT,CAAgBC,QAAhB,EAA0B;AACnD,MAAIF,WAAW,KAAKG,SAApB,EAA+B;AAC7BH,IAAAA,WAAW,GAAGI,OAAO,CAAC,cAAD,CAArB;AACD;;AAED,QAAMC,MAAM,GAAGL,WAAW,CAACE,QAAD,CAA1B;AACA,SAAOG,MAAP;AACD,CAPD;;AASA,IAAIC,SAAJ;;AACA,MAAMC,QAAoB,GAAG,SAASA,QAAT,CAAkBL,QAAlB,EAA4BM,OAA5B,EAAqC;AAChE,MAAIF,SAAS,KAAKH,SAAlB,EAA6B;AAC3BG,IAAAA,SAAS,GAAGF,OAAO,CAAC,YAAD,CAAnB;AACD;;AAED,MAAI;AACF,UAAMC,MAAM,GAAGC,SAAS,CAACE,OAAD,CAAxB;AACA,WAAOH,MAAP;AACD,GAHD,CAGE,OAAOI,KAAP,EAAc;AACdA,IAAAA,KAAK,CAACC,OAAN,GAAiB,iBAAgBR,QAAS,MAAKO,KAAK,CAACC,OAAQ,EAA7D;AACA,UAAMD,KAAN;AACD;AACF,CAZD;;AAcA,IAAIE,IAAJ;;AACA,MAAMC,QAAoB,GAAG,SAASA,QAAT,CAAkBV,QAAlB,EAA4BM,OAA5B,EAAqC;AAChE,MAAIG,IAAI,KAAKR,SAAb,EAAwB;AACtBQ,IAAAA,IAAI,GAAGP,OAAO,CAAC,MAAD,CAAd;AACD;;AAED,MAAI;AACF,UAAMC,MAAM,GAAGM,IAAI,CAACE,KAAL,CAAWL,OAAX,EAAoB;AAAEM,MAAAA,YAAY,EAAE;AAAhB,KAApB,CAAf;AACA,WAAOT,MAAP;AACD,GAHD,CAGE,OAAOI,KAAP,EAAc;AACdA,IAAAA,KAAK,CAACC,OAAN,GAAiB,iBAAgBR,QAAS,MAAKO,KAAK,CAACC,OAAQ,EAA7D;AACA,UAAMD,KAAN;AACD;AACF,CAZD;;AAcA,MAAMM,OAAoB,GAAG;AAAEd,EAAAA,MAAF;AAAUM,EAAAA,QAAV;AAAoBK,EAAAA;AAApB,CAA7B","sourcesContent":["/* eslint-disable @typescript-eslint/no-require-imports */\n\nimport parseJsonType from 'parse-json';\nimport yamlType from 'yaml';\nimport importFreshType from 'import-fresh';\nimport { LoaderSync } from './index';\nimport { LoadersSync } from './types';\n\nlet importFresh: typeof importFreshType;\nconst loadJs: LoaderSync = function loadJs(filepath) {\n  if (importFresh === undefined) {\n    importFresh = require('import-fresh');\n  }\n\n  const result = importFresh(filepath);\n  return result;\n};\n\nlet parseJson: typeof parseJsonType;\nconst loadJson: LoaderSync = function loadJson(filepath, content) {\n  if (parseJson === undefined) {\n    parseJson = require('parse-json');\n  }\n\n  try {\n    const result = parseJson(content);\n    return result;\n  } catch (error) {\n    error.message = `JSON Error in ${filepath}:\\n${error.message}`;\n    throw error;\n  }\n};\n\nlet yaml: typeof yamlType;\nconst loadYaml: LoaderSync = function loadYaml(filepath, content) {\n  if (yaml === undefined) {\n    yaml = require('yaml');\n  }\n\n  try {\n    const result = yaml.parse(content, { prettyErrors: true });\n    return result;\n  } catch (error) {\n    error.message = `YAML Error in ${filepath}:\\n${error.message}`;\n    throw error;\n  }\n};\n\nconst loaders: LoadersSync = { loadJs, loadJson, loadYaml };\n\nexport { loaders };\n"],"file":"loaders.js"}

node_modules/stylelint/node_modules/cosmiconfig/dist/readFile.d.ts

@@ -0,0 +1,7 @@
+interface Options {
+    throwNotFound?: boolean;
+}
+declare function readFile(filepath: string, options?: Options): Promise<string | null>;
+declare function readFileSync(filepath: string, options?: Options): string | null;
+export { readFile, readFileSync };
+//# sourceMappingURL=readFile.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/readFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readFile.d.ts","sourceRoot":"","sources":["../src/readFile.ts"],"names":[],"mappings":"AAkBA,UAAU,OAAO;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,iBAAe,QAAQ,CACrB,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,OAAY,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiBxB;AAED,iBAAS,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,OAAY,GAAG,MAAM,GAAG,IAAI,CAiB5E;AAED,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC"}

node_modules/stylelint/node_modules/cosmiconfig/dist/readFile.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readFile = readFile;
+exports.readFileSync = readFileSync;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function fsReadFileAsync(pathname, encoding) {
+  return new Promise((resolve, reject) => {
+    _fs.default.readFile(pathname, encoding, (error, contents) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      resolve(contents);
+    });
+  });
+}
+
+async function readFile(filepath, options = {}) {
+  const throwNotFound = options.throwNotFound === true;
+
+  try {
+    const content = await fsReadFileAsync(filepath, 'utf8');
+    return content;
+  } catch (error) {
+    if (throwNotFound === false && (error.code === 'ENOENT' || error.code === 'EISDIR')) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+function readFileSync(filepath, options = {}) {
+  const throwNotFound = options.throwNotFound === true;
+
+  try {
+    const content = _fs.default.readFileSync(filepath, 'utf8');
+
+    return content;
+  } catch (error) {
+    if (throwNotFound === false && (error.code === 'ENOENT' || error.code === 'EISDIR')) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+//# sourceMappingURL=readFile.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/readFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/readFile.ts"],"names":["fsReadFileAsync","pathname","encoding","Promise","resolve","reject","fs","readFile","error","contents","filepath","options","throwNotFound","content","code","readFileSync"],"mappings":";;;;;;;;AAAA;;;;AAEA,eAAeA,eAAf,CACEC,QADF,EAEEC,QAFF,EAGmB;AACjB,SAAO,IAAIC,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAA2B;AAC5CC,gBAAGC,QAAH,CAAYN,QAAZ,EAAsBC,QAAtB,EAAgC,CAACM,KAAD,EAAQC,QAAR,KAA2B;AACzD,UAAID,KAAJ,EAAW;AACTH,QAAAA,MAAM,CAACG,KAAD,CAAN;AACA;AACD;;AAEDJ,MAAAA,OAAO,CAACK,QAAD,CAAP;AACD,KAPD;AAQD,GATM,CAAP;AAUD;;AAMD,eAAeF,QAAf,CACEG,QADF,EAEEC,OAAgB,GAAG,EAFrB,EAG0B;AACxB,QAAMC,aAAa,GAAGD,OAAO,CAACC,aAAR,KAA0B,IAAhD;;AAEA,MAAI;AACF,UAAMC,OAAO,GAAG,MAAMb,eAAe,CAACU,QAAD,EAAW,MAAX,CAArC;AAEA,WAAOG,OAAP;AACD,GAJD,CAIE,OAAOL,KAAP,EAAc;AACd,QACEI,aAAa,KAAK,KAAlB,KACCJ,KAAK,CAACM,IAAN,KAAe,QAAf,IAA2BN,KAAK,CAACM,IAAN,KAAe,QAD3C,CADF,EAGE;AACA,aAAO,IAAP;AACD;;AAED,UAAMN,KAAN;AACD;AACF;;AAED,SAASO,YAAT,CAAsBL,QAAtB,EAAwCC,OAAgB,GAAG,EAA3D,EAA8E;AAC5E,QAAMC,aAAa,GAAGD,OAAO,CAACC,aAAR,KAA0B,IAAhD;;AAEA,MAAI;AACF,UAAMC,OAAO,GAAGP,YAAGS,YAAH,CAAgBL,QAAhB,EAA0B,MAA1B,CAAhB;;AAEA,WAAOG,OAAP;AACD,GAJD,CAIE,OAAOL,KAAP,EAAc;AACd,QACEI,aAAa,KAAK,KAAlB,KACCJ,KAAK,CAACM,IAAN,KAAe,QAAf,IAA2BN,KAAK,CAACM,IAAN,KAAe,QAD3C,CADF,EAGE;AACA,aAAO,IAAP;AACD;;AAED,UAAMN,KAAN;AACD;AACF","sourcesContent":["import fs from 'fs';\n\nasync function fsReadFileAsync(\n  pathname: string,\n  encoding: BufferEncoding,\n): Promise<string> {\n  return new Promise((resolve, reject): void => {\n    fs.readFile(pathname, encoding, (error, contents): void => {\n      if (error) {\n        reject(error);\n        return;\n      }\n\n      resolve(contents);\n    });\n  });\n}\n\ninterface Options {\n  throwNotFound?: boolean;\n}\n\nasync function readFile(\n  filepath: string,\n  options: Options = {},\n): Promise<string | null> {\n  const throwNotFound = options.throwNotFound === true;\n\n  try {\n    const content = await fsReadFileAsync(filepath, 'utf8');\n\n    return content;\n  } catch (error) {\n    if (\n      throwNotFound === false &&\n      (error.code === 'ENOENT' || error.code === 'EISDIR')\n    ) {\n      return null;\n    }\n\n    throw error;\n  }\n}\n\nfunction readFileSync(filepath: string, options: Options = {}): string | null {\n  const throwNotFound = options.throwNotFound === true;\n\n  try {\n    const content = fs.readFileSync(filepath, 'utf8');\n\n    return content;\n  } catch (error) {\n    if (\n      throwNotFound === false &&\n      (error.code === 'ENOENT' || error.code === 'EISDIR')\n    ) {\n      return null;\n    }\n\n    throw error;\n  }\n}\n\nexport { readFile, readFileSync };\n"],"file":"readFile.js"}

node_modules/stylelint/node_modules/cosmiconfig/dist/types.d.ts

@@ -0,0 +1,20 @@
+import { Loader, LoaderSync, Options, OptionsSync } from './index';
+export declare type Config = any;
+export declare type CosmiconfigResult = {
+    config: Config;
+    filepath: string;
+    isEmpty?: boolean;
+} | null;
+export interface ExplorerOptions extends Required<Options> {
+}
+export interface ExplorerOptionsSync extends Required<OptionsSync> {
+}
+export declare type Cache = Map<string, CosmiconfigResult>;
+export declare type LoadedFileContent = Config | null | undefined;
+export interface Loaders {
+    [key: string]: Loader;
+}
+export interface LoadersSync {
+    [key: string]: LoaderSync;
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/stylelint/node_modules/cosmiconfig/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGnE,oBAAY,MAAM,GAAG,GAAG,CAAC;AAEzB,oBAAY,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,IAAI,CAAC;AAIT,MAAM,WAAW,eAAgB,SAAQ,QAAQ,CAAC,OAAO,CAAC;CAAG;AAC7D,MAAM,WAAW,mBAAoB,SAAQ,QAAQ,CAAC,WAAW,CAAC;CAAG;AAGrE,oBAAY,KAAK,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAMnD,oBAAY,iBAAiB,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;AAE1D,MAAM,WAAW,OAAO;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B"}

node_modules/stylelint/node_modules/cosmiconfig/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

node_modules/stylelint/node_modules/cosmiconfig/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"types.js"}

node_modules/stylelint/node_modules/cosmiconfig/package.json

@@ -0,0 +1,145 @@
+{
+  "name": "cosmiconfig",
+  "version": "7.1.0",
+  "description": "Find and load configuration from a package.json property, rc file, or CommonJS module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "del-cli --dot=true \"./dist/**/*\"",
+    "build": "npm run clean && npm run build:compile && npm run build:types",
+    "build:compile": "cross-env NODE_ENV=production babel src -d dist --verbose --extensions .js,.ts --ignore \"**/**/*.test.js\",\"**/**/*.test.ts\" --source-maps",
+    "build:types": "cross-env NODE_ENV=production tsc --project tsconfig.types.json",
+    "dev": "npm run clean && npm run build:compile -- --watch",
+    "lint": "eslint --ext .js,.ts . && npm run lint:md",
+    "lint:fix": "eslint --ext .js,.ts . --fix",
+    "lint:md": "remark-preset-davidtheclark",
+    "format": "prettier \"**/*.{js,ts,json,yml,yaml}\" --write",
+    "format:md": "remark-preset-davidtheclark --format",
+    "format:check": "prettier \"**/*.{js,ts,json,yml,yaml}\" --check",
+    "typescript": "tsc",
+    "test": "jest --coverage",
+    "test:watch": "jest --watch",
+    "check:all": "npm run test && npm run typescript && npm run lint && npm run format:check",
+    "prepublishOnly": "npm run check:all && npm run build"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged && npm run typescript && npm run test",
+      "pre-push": "npm run check:all"
+    }
+  },
+  "lint-staged": {
+    "*.{js,ts}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,yml,yaml}": [
+      "prettier --write"
+    ],
+    "*.md": [
+      "remark-preset-davidtheclark",
+      "remark-preset-davidtheclark --format"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davidtheclark/cosmiconfig.git"
+  },
+  "keywords": [
+    "load",
+    "configuration",
+    "config"
+  ],
+  "author": "David Clark <david.dave.clark@gmail.com>",
+  "contributors": [
+    "Bogdan Chadkin <trysound@yandex.ru>",
+    "Suhas Karanth <sudo.suhas@gmail.com>"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/davidtheclark/cosmiconfig/issues"
+  },
+  "homepage": "https://github.com/davidtheclark/cosmiconfig#readme",
+  "prettier": {
+    "trailingComma": "all",
+    "arrowParens": "always",
+    "singleQuote": true,
+    "printWidth": 80,
+    "tabWidth": 2
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "collectCoverageFrom": [
+      "src/**/*.{js,ts}"
+    ],
+    "coverageReporters": [
+      "text",
+      "html",
+      "lcov"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 100,
+        "functions": 100,
+        "lines": 100,
+        "statements": 100
+      }
+    },
+    "resetModules": true,
+    "resetMocks": true,
+    "restoreMocks": true
+  },
+  "babel": {
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": {
+            "node": "10"
+          }
+        }
+      ],
+      "@babel/preset-typescript"
+    ]
+  },
+  "dependencies": {
+    "@types/parse-json": "^4.0.0",
+    "import-fresh": "^3.2.1",
+    "parse-json": "^5.0.0",
+    "path-type": "^4.0.0",
+    "yaml": "^1.10.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.10.4",
+    "@babel/core": "^7.10.4",
+    "@babel/preset-env": "^7.10.4",
+    "@babel/preset-typescript": "^7.10.4",
+    "@types/jest": "^26.0.4",
+    "@types/node": "^14.0.22",
+    "@typescript-eslint/eslint-plugin": "^3.6.0",
+    "@typescript-eslint/parser": "^3.6.0",
+    "cross-env": "^7.0.2",
+    "del": "^5.1.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.4.0",
+    "eslint-config-davidtheclark-node": "^0.2.2",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-import": "^2.22.0",
+    "eslint-plugin-jest": "^23.18.0",
+    "eslint-plugin-node": "^11.1.0",
+    "husky": "^4.2.5",
+    "jest": "^26.1.0",
+    "lint-staged": "^10.2.11",
+    "make-dir": "^3.1.0",
+    "parent-module": "^2.0.0",
+    "prettier": "^2.0.5",
+    "remark-preset-davidtheclark": "^0.12.0",
+    "typescript": "^3.9.6"
+  },
+  "engines": {
+    "node": ">=10"
+  }
+}

node_modules/stylelint/node_modules/global-modules/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present, Jon Schlinkert.
+
+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/stylelint/node_modules/global-modules/README.md

@@ -0,0 +1,87 @@
+# global-modules [![NPM version](https://img.shields.io/npm/v/global-modules.svg?style=flat)](https://www.npmjs.com/package/global-modules) [![NPM monthly downloads](https://img.shields.io/npm/dm/global-modules.svg?style=flat)](https://npmjs.org/package/global-modules) [![NPM total downloads](https://img.shields.io/npm/dt/global-modules.svg?style=flat)](https://npmjs.org/package/global-modules) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/global-modules.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/global-modules)
+
+> The directory used by npm for globally installed npm modules.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save global-modules
+```
+
+## Usage
+
+```js
+const globalModules = require('global-modules');
+console.log(globalModules);
+//=> '/usr/local/lib/node_modules' 
+```
+_(Note that this path might be different based on platform, user-defined configuration settings, etc)_
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [git-config-path](https://www.npmjs.com/package/git-config-path): Resolve the path to the user's local or global .gitconfig. | [homepage](https://github.com/jonschlinkert/git-config-path "Resolve the path to the user's local or global .gitconfig.")
+* [global-prefix](https://www.npmjs.com/package/global-prefix): Get the npm global path prefix. | [homepage](https://github.com/jonschlinkert/global-prefix "Get the npm global path prefix.")
+* [npm-paths](https://www.npmjs.com/package/npm-paths): Returns an array of unique "npm" directories based on the user's platform and environment. | [homepage](https://github.com/jonschlinkert/npm-paths "Returns an array of unique "npm" directories based on the user's platform and environment.")
+
+### Contributors
+
+| **Commits** | **Contributor** |  
+| --- | --- |  
+| 20 | [jonschlinkert](https://github.com/jonschlinkert) |  
+| 1  | [Kikobeats](https://github.com/Kikobeats) |  
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on December 14, 2018._

node_modules/stylelint/node_modules/global-modules/index.js

@@ -0,0 +1,29 @@
+/*!
+ * global-modules <https://github.com/jonschlinkert/global-modules>
+ *
+ * Copyright (c) 2015-2017 Jon Schlinkert.
+ * Licensed under the MIT license.
+ */
+
+'use strict';
+
+const path = require('path');
+const prefix = require('global-prefix');
+let gm;
+
+function getPath() {
+  if (process.platform === 'win32' || process.env.OSTYPE === 'msys' || process.env.OSTYPE === 'cygwin') {
+    return path.resolve(prefix, 'node_modules');
+  }
+  return path.resolve(prefix, 'lib/node_modules');
+}
+
+/**
+ * Expose `global-modules` path
+ */
+
+Reflect.defineProperty(module, 'exports', {
+  get() {
+    return gm || (gm = getPath());
+  }
+});

node_modules/stylelint/node_modules/global-modules/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "global-modules",
+  "description": "The directory used by npm for globally installed npm modules.",
+  "version": "2.0.0",
+  "homepage": "https://github.com/jonschlinkert/global-modules",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "contributors": [
+    "JasonChang (https://packagist.org/packages/jason-chang)",
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Kiko Beats (https://kikobeats.com)"
+  ],
+  "repository": "jonschlinkert/global-modules",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/global-modules/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=6"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "global-prefix": "^3.0.0"
+  },
+  "devDependencies": {
+    "gulp-format-md": "^2.0.0",
+    "mocha": "^5.2.0"
+  },
+  "keywords": [
+    "directory",
+    "dirname",
+    "global",
+    "module",
+    "modules",
+    "package",
+    "path",
+    "prefix",
+    "resolve"
+  ],
+  "verb": {
+    "run": true,
+    "toc": false,
+    "layout": "default",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "related": {
+      "list": [
+        "git-config-path",
+        "global-prefix",
+        "npm-paths"
+      ]
+    },
+    "lint": {
+      "reflinks": true
+    }
+  }
+}

node_modules/stylelint/node_modules/global-prefix/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present, Jon Schlinkert.
+
+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/stylelint/node_modules/global-prefix/README.md

@@ -0,0 +1,92 @@
+# global-prefix [![NPM version](https://img.shields.io/npm/v/global-prefix.svg?style=flat)](https://www.npmjs.com/package/global-prefix) [![NPM monthly downloads](https://img.shields.io/npm/dm/global-prefix.svg?style=flat)](https://npmjs.org/package/global-prefix) [![NPM total downloads](https://img.shields.io/npm/dt/global-prefix.svg?style=flat)](https://npmjs.org/package/global-prefix) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/global-prefix.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/global-prefix) [![Windows Build Status](https://img.shields.io/appveyor/ci/jonschlinkert/global-prefix.svg?style=flat&label=AppVeyor)](https://ci.appveyor.com/project/jonschlinkert/global-prefix)
+
+> Get the npm global path prefix.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save global-prefix
+```
+
+This is partially based on the code used by npm internally to resolve the global prefix.
+
+## Usage
+
+```js
+var prefix = require('global-prefix');
+//=> '/usr/local' (this path will differ by system and user-defined config)
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [global-modules](https://www.npmjs.com/package/global-modules): The directory used by npm for globally installed npm modules. | [homepage](https://github.com/jonschlinkert/global-modules "The directory used by npm for globally installed npm modules.")
+* [global-paths](https://www.npmjs.com/package/global-paths): Returns an array of unique "global" directories based on the user's platform and environment. The… [more](https://github.com/jonschlinkert/global-paths) | [homepage](https://github.com/jonschlinkert/global-paths "Returns an array of unique "global" directories based on the user's platform and environment. The resulting paths can be used for doing lookups for generators or other globally installed npm packages. Node.js / JavaScript.")
+
+### Contributors
+
+| **Commits** | **Contributor** | 
+| --- | --- |
+| 23 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 15 | [doowb](https://github.com/doowb) |
+| 2 | [phated](https://github.com/phated) |
+| 1 | [rmbaad](https://github.com/rmbaad) |
+| 1 | [avengerpenguin](https://github.com/avengerpenguin) |
+| 1 | [jorrit](https://github.com/jorrit) |
+| 1 | [mathiasvr](https://github.com/mathiasvr) |
+| 1 | [tunnckoCore](https://github.com/tunnckoCore) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on October 11, 2018._

node_modules/stylelint/node_modules/global-prefix/index.js

@@ -0,0 +1,85 @@
+/*!
+ * global-prefix <https://github.com/jonschlinkert/global-prefix>
+ *
+ * Copyright (c) 2015-present Jon Schlinkert.
+ * Licensed under the MIT license.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const ini = require('ini');
+let prefix;
+
+const getPrefix = () => {
+  if (process.env.PREFIX) return process.env.PREFIX;
+  if (prefix) return prefix;
+
+  // Start by checking if the global prefix is set by the user
+  let home = os.homedir();
+
+  // os.homedir() returns undefined if $HOME is not set; path.resolve requires strings
+  if (home) {
+    prefix = tryConfigPath(path.resolve(home, '.npmrc'));
+  }
+
+  if (prefix) {
+    return prefix;
+  }
+
+  // Otherwise find the path of npm
+  let npm = tryNpmPath();
+  if (npm) {
+    // Check the built-in npm config file
+    prefix = tryConfigPath(path.resolve(npm, '..', '..', 'npmrc'));
+
+    if (prefix) {
+      // Now the global npm config can also be checked.
+      prefix = tryConfigPath(path.resolve(prefix, 'etc', 'npmrc')) || prefix;
+    }
+  }
+
+  if (!prefix) {
+    let { APPDATA, DESTDIR, OSTYPE } = process.env;
+
+    // c:\node\node.exe --> prefix=c:\node\
+    if (process.platform === 'win32' || OSTYPE === 'msys' || OSTYPE === 'cygwin') {
+      prefix = APPDATA ? path.join(APPDATA, 'npm') : path.dirname(process.execPath);
+      return prefix;
+    }
+
+    // /usr/local/bin/node --> prefix=/usr/local
+    prefix = path.dirname(path.dirname(process.execPath));
+
+    // destdir only is respected on Unix
+    if (DESTDIR) {
+      prefix = path.join(DESTDIR, prefix);
+    }
+  }
+
+  return prefix;
+}
+
+function tryNpmPath() {
+  try {
+    return fs.realpathSync(require('which').sync('npm'));
+  } catch (err) { /* do nothing */ }
+}
+
+function tryConfigPath(configPath) {
+  try {
+    return ini.parse(fs.readFileSync(configPath, 'utf-8')).prefix;
+  } catch (err) { /* do nothing */ }
+}
+
+/**
+ * Expose `prefix`
+ */
+
+Reflect.defineProperty(module, 'exports', {
+  get() {
+    return getPrefix();
+  }
+});

node_modules/stylelint/node_modules/global-prefix/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "global-prefix",
+  "description": "Get the npm global path prefix.",
+  "version": "3.0.0",
+  "homepage": "https://github.com/jonschlinkert/global-prefix",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "contributors": [
+    "Alexandr Bogachev (https://github.com/rmbaad)",
+    "Brian Woodward (https://twitter.com/doowb)",
+    "Charlike Mike Reagent (https://i.am.charlike.online)",
+    "JasonChang (https://packagist.org/packages/jason-chang)",
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Jorrit Schippers (https://www.ncode.nl)",
+    "Mathias Rasmussen (chrome://dino)",
+    "Ross Fenning (http://rossfenning.co.uk)"
+  ],
+  "repository": "jonschlinkert/global-prefix",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/global-prefix/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=6"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "ini": "^1.3.5",
+    "kind-of": "^6.0.2",
+    "which": "^1.3.1"
+  },
+  "devDependencies": {
+    "gulp-format-md": "^2.0.0",
+    "mocha": "^5.2.0"
+  },
+  "keywords": [
+    "global",
+    "module",
+    "modules",
+    "npm",
+    "path",
+    "prefix",
+    "resolve"
+  ]
+}

node_modules/stylelint/node_modules/kind-of/CHANGELOG.md

@@ -0,0 +1,160 @@
+# Release history
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+<details>
+  <summary><strong>Guiding Principles</strong></summary>
+
+- Changelogs are for humans, not machines.
+- There should be an entry for every single version.
+- The same types of changes should be grouped.
+- Versions and sections should be linkable.
+- The latest version comes first.
+- The release date of each versions is displayed.
+- Mention whether you follow Semantic Versioning.
+
+</details>
+
+<details>
+  <summary><strong>Types of changes</strong></summary>
+
+Changelog entries are classified using the following labels _(from [keep-a-changelog](http://keepachangelog.com/)_):
+
+- `Added` for new features.
+- `Changed` for changes in existing functionality.
+- `Deprecated` for soon-to-be removed features.
+- `Removed` for now removed features.
+- `Fixed` for any bug fixes.
+- `Security` in case of vulnerabilities.
+
+</details>
+
+## [6.0.3] - 2020-01-16
+
+- Merge pull request #31 for issue #30
+
+## [6.0.0] - 2017-10-13
+
+- refactor code to be more performant
+- refactor benchmarks
+
+## [5.1.0] - 2017-10-13
+
+**Added**
+
+- Merge pull request #15 from aretecode/patch-1
+- adds support and tests for string & array iterators
+
+**Changed**
+
+- updates benchmarks
+
+## [5.0.2] - 2017-08-02
+
+- Merge pull request #14 from struct78/master
+- Added `undefined` check
+
+## [5.0.0] - 2017-06-21
+
+- Merge pull request #12 from aretecode/iterator
+- Set Iterator + Map Iterator
+- streamline `isbuffer`, minor edits
+
+## [4.0.0] - 2017-05-19
+
+- Merge pull request #8 from tunnckoCore/master
+- update deps
+
+## [3.2.2] - 2017-05-16
+
+- fix version
+
+## [3.2.1] - 2017-05-16
+
+- add browserify
+
+## [3.2.0] - 2017-04-25
+
+- Merge pull request #10 from ksheedlo/unrequire-buffer
+- add `promise` support and tests
+- Remove unnecessary `Buffer` check
+
+## [3.1.0] - 2016-12-07
+
+- Merge pull request #7 from laggingreflex/err
+- add support for `error` and tests
+- run update
+
+## [3.0.4] - 2016-07-29
+
+- move tests
+- run update
+
+## [3.0.3] - 2016-05-03
+
+- fix prepublish script
+- remove unused dep
+
+## [3.0.0] - 2015-11-17
+
+- add typed array support
+- Merge pull request #5 from miguelmota/typed-arrays
+- adds new tests
+
+## [2.0.1] - 2015-08-21
+
+- use `is-buffer` module
+
+## [2.0.0] - 2015-05-31
+
+- Create fallback for `Array.isArray` if used as a browser package
+- Merge pull request #2 from dtothefp/patch-1
+- Merge pull request #3 from pdehaan/patch-1
+- Merge branch 'master' of https://github.com/chorks/kind-of into chorks-master
+- optimizations, mostly date and regex
+
+## [1.1.0] - 2015-02-09
+
+- adds `buffer` support
+- adds tests for `buffer`
+
+## [1.0.0] - 2015-01-19
+
+- update benchmarks
+- optimizations based on benchmarks
+
+## [0.1.2] - 2014-10-26
+
+- return `typeof` value if it's not an object. very slight speed improvement
+- use `.slice`
+- adds benchmarks
+
+## [0.1.0] - 2014-9-26
+
+- first commit
+
+[6.0.0]: https://github.com/jonschlinkert/kind-of/compare/5.1.0...6.0.0
+[5.1.0]: https://github.com/jonschlinkert/kind-of/compare/5.0.2...5.1.0
+[5.0.2]: https://github.com/jonschlinkert/kind-of/compare/5.0.1...5.0.2
+[5.0.1]: https://github.com/jonschlinkert/kind-of/compare/5.0.0...5.0.1
+[5.0.0]: https://github.com/jonschlinkert/kind-of/compare/4.0.0...5.0.0
+[4.0.0]: https://github.com/jonschlinkert/kind-of/compare/3.2.2...4.0.0
+[3.2.2]: https://github.com/jonschlinkert/kind-of/compare/3.2.1...3.2.2
+[3.2.1]: https://github.com/jonschlinkert/kind-of/compare/3.2.0...3.2.1
+[3.2.0]: https://github.com/jonschlinkert/kind-of/compare/3.1.0...3.2.0
+[3.1.0]: https://github.com/jonschlinkert/kind-of/compare/3.0.4...3.1.0
+[3.0.4]: https://github.com/jonschlinkert/kind-of/compare/3.0.3...3.0.4
+[3.0.3]: https://github.com/jonschlinkert/kind-of/compare/3.0.0...3.0.3
+[3.0.0]: https://github.com/jonschlinkert/kind-of/compare/2.0.1...3.0.0
+[2.0.1]: https://github.com/jonschlinkert/kind-of/compare/2.0.0...2.0.1
+[2.0.0]: https://github.com/jonschlinkert/kind-of/compare/1.1.0...2.0.0
+[1.1.0]: https://github.com/jonschlinkert/kind-of/compare/1.0.0...1.1.0
+[1.0.0]: https://github.com/jonschlinkert/kind-of/compare/0.1.2...1.0.0
+[0.1.2]: https://github.com/jonschlinkert/kind-of/compare/0.1.0...0.1.2
+[0.1.0]: https://github.com/jonschlinkert/kind-of/commit/2fae09b0b19b1aadb558e9be39f0c3ef6034eb87
+
+[Unreleased]: https://github.com/jonschlinkert/kind-of/compare/0.1.2...HEAD
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog

node_modules/stylelint/node_modules/kind-of/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2017, Jon Schlinkert.
+
+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/stylelint/node_modules/kind-of/README.md

@@ -0,0 +1,367 @@
+# kind-of [![NPM version](https://img.shields.io/npm/v/kind-of.svg?style=flat)](https://www.npmjs.com/package/kind-of) [![NPM monthly downloads](https://img.shields.io/npm/dm/kind-of.svg?style=flat)](https://npmjs.org/package/kind-of) [![NPM total downloads](https://img.shields.io/npm/dt/kind-of.svg?style=flat)](https://npmjs.org/package/kind-of) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/kind-of.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/kind-of)
+
+> Get the native type of a value.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save kind-of
+```
+
+Install with [bower](https://bower.io/)
+
+```sh
+$ bower install kind-of --save
+```
+
+## Why use this?
+
+1. [it's fast](#benchmarks) | [optimizations](#optimizations)
+2. [better type checking](#better-type-checking)
+
+## Usage
+
+> es5, es6, and browser ready
+
+```js
+var kindOf = require('kind-of');
+
+kindOf(undefined);
+//=> 'undefined'
+
+kindOf(null);
+//=> 'null'
+
+kindOf(true);
+//=> 'boolean'
+
+kindOf(false);
+//=> 'boolean'
+
+kindOf(new Buffer(''));
+//=> 'buffer'
+
+kindOf(42);
+//=> 'number'
+
+kindOf('str');
+//=> 'string'
+
+kindOf(arguments);
+//=> 'arguments'
+
+kindOf({});
+//=> 'object'
+
+kindOf(Object.create(null));
+//=> 'object'
+
+kindOf(new Test());
+//=> 'object'
+
+kindOf(new Date());
+//=> 'date'
+
+kindOf([1, 2, 3]);
+//=> 'array'
+
+kindOf(/foo/);
+//=> 'regexp'
+
+kindOf(new RegExp('foo'));
+//=> 'regexp'
+
+kindOf(new Error('error'));
+//=> 'error'
+
+kindOf(function () {});
+//=> 'function'
+
+kindOf(function * () {});
+//=> 'generatorfunction'
+
+kindOf(Symbol('str'));
+//=> 'symbol'
+
+kindOf(new Map());
+//=> 'map'
+
+kindOf(new WeakMap());
+//=> 'weakmap'
+
+kindOf(new Set());
+//=> 'set'
+
+kindOf(new WeakSet());
+//=> 'weakset'
+
+kindOf(new Int8Array());
+//=> 'int8array'
+
+kindOf(new Uint8Array());
+//=> 'uint8array'
+
+kindOf(new Uint8ClampedArray());
+//=> 'uint8clampedarray'
+
+kindOf(new Int16Array());
+//=> 'int16array'
+
+kindOf(new Uint16Array());
+//=> 'uint16array'
+
+kindOf(new Int32Array());
+//=> 'int32array'
+
+kindOf(new Uint32Array());
+//=> 'uint32array'
+
+kindOf(new Float32Array());
+//=> 'float32array'
+
+kindOf(new Float64Array());
+//=> 'float64array'
+```
+
+## Benchmarks
+
+Benchmarked against [typeof](http://github.com/CodingFu/typeof) and [type-of](https://github.com/ForbesLindesay/type-of).
+
+```bash
+# arguments (32 bytes)
+  kind-of x 17,024,098 ops/sec ±1.90% (86 runs sampled)
+  lib-type-of x 11,926,235 ops/sec ±1.34% (83 runs sampled)
+  lib-typeof x 9,245,257 ops/sec ±1.22% (87 runs sampled)
+
+  fastest is kind-of (by 161% avg)
+
+# array (22 bytes)
+  kind-of x 17,196,492 ops/sec ±1.07% (88 runs sampled)
+  lib-type-of x 8,838,283 ops/sec ±1.02% (87 runs sampled)
+  lib-typeof x 8,677,848 ops/sec ±0.87% (87 runs sampled)
+
+  fastest is kind-of (by 196% avg)
+
+# boolean (24 bytes)
+  kind-of x 16,841,600 ops/sec ±1.10% (86 runs sampled)
+  lib-type-of x 8,096,787 ops/sec ±0.95% (87 runs sampled)
+  lib-typeof x 8,423,345 ops/sec ±1.15% (86 runs sampled)
+
+  fastest is kind-of (by 204% avg)
+
+# buffer (38 bytes)
+  kind-of x 14,848,060 ops/sec ±1.05% (86 runs sampled)
+  lib-type-of x 3,671,577 ops/sec ±1.49% (87 runs sampled)
+  lib-typeof x 8,360,236 ops/sec ±1.24% (86 runs sampled)
+
+  fastest is kind-of (by 247% avg)
+
+# date (30 bytes)
+  kind-of x 16,067,761 ops/sec ±1.58% (86 runs sampled)
+  lib-type-of x 8,954,436 ops/sec ±1.40% (87 runs sampled)
+  lib-typeof x 8,488,307 ops/sec ±1.51% (84 runs sampled)
+
+  fastest is kind-of (by 184% avg)
+
+# error (36 bytes)
+  kind-of x 9,634,090 ops/sec ±1.12% (89 runs sampled)
+  lib-type-of x 7,735,624 ops/sec ±1.32% (86 runs sampled)
+  lib-typeof x 7,442,160 ops/sec ±1.11% (90 runs sampled)
+
+  fastest is kind-of (by 127% avg)
+
+# function (34 bytes)
+  kind-of x 10,031,494 ops/sec ±1.27% (86 runs sampled)
+  lib-type-of x 9,502,757 ops/sec ±1.17% (89 runs sampled)
+  lib-typeof x 8,278,985 ops/sec ±1.08% (88 runs sampled)
+
+  fastest is kind-of (by 113% avg)
+
+# null (24 bytes)
+  kind-of x 18,159,808 ops/sec ±1.92% (86 runs sampled)
+  lib-type-of x 12,927,635 ops/sec ±1.01% (88 runs sampled)
+  lib-typeof x 7,958,234 ops/sec ±1.21% (89 runs sampled)
+
+  fastest is kind-of (by 174% avg)
+
+# number (22 bytes)
+  kind-of x 17,846,779 ops/sec ±0.91% (85 runs sampled)
+  lib-type-of x 3,316,636 ops/sec ±1.19% (86 runs sampled)
+  lib-typeof x 2,329,477 ops/sec ±2.21% (85 runs sampled)
+
+  fastest is kind-of (by 632% avg)
+
+# object-plain (47 bytes)
+  kind-of x 7,085,155 ops/sec ±1.05% (88 runs sampled)
+  lib-type-of x 8,870,930 ops/sec ±1.06% (83 runs sampled)
+  lib-typeof x 8,716,024 ops/sec ±1.05% (87 runs sampled)
+
+  fastest is lib-type-of (by 112% avg)
+
+# regex (25 bytes)
+  kind-of x 14,196,052 ops/sec ±1.65% (84 runs sampled)
+  lib-type-of x 9,554,164 ops/sec ±1.25% (88 runs sampled)
+  lib-typeof x 8,359,691 ops/sec ±1.07% (87 runs sampled)
+
+  fastest is kind-of (by 158% avg)
+
+# string (33 bytes)
+  kind-of x 16,131,428 ops/sec ±1.41% (85 runs sampled)
+  lib-type-of x 7,273,172 ops/sec ±1.05% (87 runs sampled)
+  lib-typeof x 7,382,635 ops/sec ±1.17% (85 runs sampled)
+
+  fastest is kind-of (by 220% avg)
+
+# symbol (34 bytes)
+  kind-of x 17,011,537 ops/sec ±1.24% (86 runs sampled)
+  lib-type-of x 3,492,454 ops/sec ±1.23% (89 runs sampled)
+  lib-typeof x 7,471,235 ops/sec ±2.48% (87 runs sampled)
+
+  fastest is kind-of (by 310% avg)
+
+# template-strings (36 bytes)
+  kind-of x 15,434,250 ops/sec ±1.46% (83 runs sampled)
+  lib-type-of x 7,157,907 ops/sec ±0.97% (87 runs sampled)
+  lib-typeof x 7,517,986 ops/sec ±0.92% (86 runs sampled)
+
+  fastest is kind-of (by 210% avg)
+
+# undefined (29 bytes)
+  kind-of x 19,167,115 ops/sec ±1.71% (87 runs sampled)
+  lib-type-of x 15,477,740 ops/sec ±1.63% (85 runs sampled)
+  lib-typeof x 19,075,495 ops/sec ±1.17% (83 runs sampled)
+
+  fastest is lib-typeof,kind-of
+
+```
+
+## Optimizations
+
+In 7 out of 8 cases, this library is 2x-10x faster than other top libraries included in the benchmarks. There are a few things that lead to this performance advantage, none of them hard and fast rules, but all of them simple and repeatable in almost any code library:
+
+1. Optimize around the fastest and most common use cases first. Of course, this will change from project-to-project, but I took some time to understand how and why `typeof` checks were being used in my own libraries and other libraries I use a lot.
+2. Optimize around bottlenecks - In other words, the order in which conditionals are implemented is significant, because each check is only as fast as the failing checks that came before it. Here, the biggest bottleneck by far is checking for plain objects (an object that was created by the `Object` constructor). I opted to make this check happen by process of elimination rather than brute force up front (e.g. by using something like `val.constructor.name`), so that every other type check would not be penalized it.
+3. Don't do uneccessary processing - why do `.slice(8, -1).toLowerCase();` just to get the word `regex`? It's much faster to do `if (type === '[object RegExp]') return 'regex'`
+4. There is no reason to make the code in a microlib as terse as possible, just to win points for making it shorter. It's always better to favor performant code over terse code. You will always only be using a single `require()` statement to use the library anyway, regardless of how the code is written.
+
+## Better type checking
+
+kind-of seems to be more consistently "correct" than other type checking libs I've looked at. For example, here are some differing results from other popular libs:
+
+### [typeof](https://github.com/CodingFu/typeof) lib
+
+Incorrectly identifies instances of custom constructors (pretty common):
+
+```js
+var typeOf = require('typeof');
+function Test() {}
+console.log(typeOf(new Test()));
+//=> 'test'
+```
+
+Returns `object` instead of `arguments`:
+
+```js
+function foo() {
+  console.log(typeOf(arguments)) //=> 'object'
+}
+foo();
+```
+
+### [type-of](https://github.com/ForbesLindesay/type-of) lib
+
+Incorrectly returns `object` for generator functions, buffers, `Map`, `Set`, `WeakMap` and `WeakSet`:
+
+```js
+function * foo() {}
+console.log(typeOf(foo));
+//=> 'object'
+console.log(typeOf(new Buffer('')));
+//=> 'object'
+console.log(typeOf(new Map()));
+//=> 'object'
+console.log(typeOf(new Set()));
+//=> 'object'
+console.log(typeOf(new WeakMap()));
+//=> 'object'
+console.log(typeOf(new WeakSet()));
+//=> 'object'
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [is-glob](https://www.npmjs.com/package/is-glob): Returns `true` if the given string looks like a glob pattern or an extglob pattern… [more](https://github.com/micromatch/is-glob) | [homepage](https://github.com/micromatch/is-glob "Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a bet")
+* [is-number](https://www.npmjs.com/package/is-number): Returns true if a number or string value is a finite number. Useful for regex… [more](https://github.com/jonschlinkert/is-number) | [homepage](https://github.com/jonschlinkert/is-number "Returns true if a number or string value is a finite number. Useful for regex matches, parsing, user input, etc.")
+* [is-primitive](https://www.npmjs.com/package/is-primitive): Returns `true` if the value is a primitive.  | [homepage](https://github.com/jonschlinkert/is-primitive "Returns `true` if the value is a primitive. ")
+
+### Contributors
+
+| **Commits** | **Contributor** |  
+| --- | --- |  
+| 102 | [jonschlinkert](https://github.com/jonschlinkert) |  
+| 3   | [aretecode](https://github.com/aretecode) |  
+| 2   | [miguelmota](https://github.com/miguelmota) |  
+| 1   | [doowb](https://github.com/doowb) |  
+| 1   | [dtothefp](https://github.com/dtothefp) |  
+| 1   | [ianstormtaylor](https://github.com/ianstormtaylor) |  
+| 1   | [ksheedlo](https://github.com/ksheedlo) |  
+| 1   | [pdehaan](https://github.com/pdehaan) |  
+| 1   | [laggingreflex](https://github.com/laggingreflex) |  
+| 1   | [tunnckoCore](https://github.com/tunnckoCore) |  
+| 1   | [xiaofen9](https://github.com/xiaofen9) |  
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2020, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on January 16, 2020._

node_modules/stylelint/node_modules/kind-of/index.js

@@ -0,0 +1,129 @@
+var toString = Object.prototype.toString;
+
+module.exports = function kindOf(val) {
+  if (val === void 0) return 'undefined';
+  if (val === null) return 'null';
+
+  var type = typeof val;
+  if (type === 'boolean') return 'boolean';
+  if (type === 'string') return 'string';
+  if (type === 'number') return 'number';
+  if (type === 'symbol') return 'symbol';
+  if (type === 'function') {
+    return isGeneratorFn(val) ? 'generatorfunction' : 'function';
+  }
+
+  if (isArray(val)) return 'array';
+  if (isBuffer(val)) return 'buffer';
+  if (isArguments(val)) return 'arguments';
+  if (isDate(val)) return 'date';
+  if (isError(val)) return 'error';
+  if (isRegexp(val)) return 'regexp';
+
+  switch (ctorName(val)) {
+    case 'Symbol': return 'symbol';
+    case 'Promise': return 'promise';
+
+    // Set, Map, WeakSet, WeakMap
+    case 'WeakMap': return 'weakmap';
+    case 'WeakSet': return 'weakset';
+    case 'Map': return 'map';
+    case 'Set': return 'set';
+
+    // 8-bit typed arrays
+    case 'Int8Array': return 'int8array';
+    case 'Uint8Array': return 'uint8array';
+    case 'Uint8ClampedArray': return 'uint8clampedarray';
+
+    // 16-bit typed arrays
+    case 'Int16Array': return 'int16array';
+    case 'Uint16Array': return 'uint16array';
+
+    // 32-bit typed arrays
+    case 'Int32Array': return 'int32array';
+    case 'Uint32Array': return 'uint32array';
+    case 'Float32Array': return 'float32array';
+    case 'Float64Array': return 'float64array';
+  }
+
+  if (isGeneratorObj(val)) {
+    return 'generator';
+  }
+
+  // Non-plain objects
+  type = toString.call(val);
+  switch (type) {
+    case '[object Object]': return 'object';
+    // iterators
+    case '[object Map Iterator]': return 'mapiterator';
+    case '[object Set Iterator]': return 'setiterator';
+    case '[object String Iterator]': return 'stringiterator';
+    case '[object Array Iterator]': return 'arrayiterator';
+  }
+
+  // other
+  return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
+};
+
+function ctorName(val) {
+  return typeof val.constructor === 'function' ? val.constructor.name : null;
+}
+
+function isArray(val) {
+  if (Array.isArray) return Array.isArray(val);
+  return val instanceof Array;
+}
+
+function isError(val) {
+  return val instanceof Error || (typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number');
+}
+
+function isDate(val) {
+  if (val instanceof Date) return true;
+  return typeof val.toDateString === 'function'
+    && typeof val.getDate === 'function'
+    && typeof val.setDate === 'function';
+}
+
+function isRegexp(val) {
+  if (val instanceof RegExp) return true;
+  return typeof val.flags === 'string'
+    && typeof val.ignoreCase === 'boolean'
+    && typeof val.multiline === 'boolean'
+    && typeof val.global === 'boolean';
+}
+
+function isGeneratorFn(name, val) {
+  return ctorName(name) === 'GeneratorFunction';
+}
+
+function isGeneratorObj(val) {
+  return typeof val.throw === 'function'
+    && typeof val.return === 'function'
+    && typeof val.next === 'function';
+}
+
+function isArguments(val) {
+  try {
+    if (typeof val.length === 'number' && typeof val.callee === 'function') {
+      return true;
+    }
+  } catch (err) {
+    if (err.message.indexOf('callee') !== -1) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * If you need to support Safari 5-7 (8-10 yr-old browser),
+ * take a look at https://github.com/feross/is-buffer
+ */
+
+function isBuffer(val) {
+  if (val.constructor && typeof val.constructor.isBuffer === 'function') {
+    return val.constructor.isBuffer(val);
+  }
+  return false;
+}

node_modules/stylelint/node_modules/kind-of/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "kind-of",
+  "description": "Get the native type of a value.",
+  "version": "6.0.3",
+  "homepage": "https://github.com/jonschlinkert/kind-of",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "contributors": [
+    "David Fox-Powell (https://dtothefp.github.io/me)",
+    "James (https://twitter.com/aretecode)",
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Ken Sheedlo (kensheedlo.com)",
+    "laggingreflex (https://github.com/laggingreflex)",
+    "Miguel Mota (https://miguelmota.com)",
+    "Peter deHaan (http://about.me/peterdehaan)",
+    "tunnckoCore (https://i.am.charlike.online)"
+  ],
+  "repository": "jonschlinkert/kind-of",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/kind-of/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha",
+    "prepublish": "browserify -o browser.js -e index.js -s index --bare"
+  },
+  "devDependencies": {
+    "benchmarked": "^2.0.0",
+    "browserify": "^14.4.0",
+    "gulp-format-md": "^1.0.0",
+    "mocha": "^4.0.1",
+    "write": "^1.0.3"
+  },
+  "keywords": [
+    "arguments",
+    "array",
+    "boolean",
+    "check",
+    "date",
+    "function",
+    "is",
+    "is-type",
+    "is-type-of",
+    "kind",
+    "kind-of",
+    "number",
+    "object",
+    "of",
+    "regexp",
+    "string",
+    "test",
+    "type",
+    "type-of",
+    "typeof",
+    "types"
+  ],
+  "verb": {
+    "toc": false,
+    "layout": "default",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "lint": {
+      "reflinks": true
+    },
+    "related": {
+      "list": [
+        "is-glob",
+        "is-number",
+        "is-primitive"
+      ]
+    },
+    "reflinks": [
+      "type-of",
+      "typeof",
+      "verb"
+    ]
+  }
+}