删除

admin/node_modules/sass-loader/node_modules/neo-async/everyLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').everyLimit;

admin/node_modules/sass-loader/node_modules/neo-async/everySeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').everySeries;

admin/node_modules/sass-loader/node_modules/neo-async/fast.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').fast;

admin/node_modules/sass-loader/node_modules/neo-async/filter.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').filter;

admin/node_modules/sass-loader/node_modules/neo-async/filterLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').filterLimit;

admin/node_modules/sass-loader/node_modules/neo-async/filterSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').filterSeries;

admin/node_modules/sass-loader/node_modules/neo-async/find.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').find;

admin/node_modules/sass-loader/node_modules/neo-async/findLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').findLimit;

admin/node_modules/sass-loader/node_modules/neo-async/findSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').findSeries;

admin/node_modules/sass-loader/node_modules/neo-async/foldl.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').foldl;

admin/node_modules/sass-loader/node_modules/neo-async/foldr.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').foldr;

admin/node_modules/sass-loader/node_modules/neo-async/forEach.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').forEach;

admin/node_modules/sass-loader/node_modules/neo-async/forEachLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').forEachLimit;

admin/node_modules/sass-loader/node_modules/neo-async/forEachOf.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').forEachOf;

admin/node_modules/sass-loader/node_modules/neo-async/forEachOfLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').forEachOfLimit;

admin/node_modules/sass-loader/node_modules/neo-async/forEachOfSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').forEachOfSeries;

admin/node_modules/sass-loader/node_modules/neo-async/forEachSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').forEachSeries;

admin/node_modules/sass-loader/node_modules/neo-async/forever.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').forever;

admin/node_modules/sass-loader/node_modules/neo-async/groupBy.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').groupBy;

admin/node_modules/sass-loader/node_modules/neo-async/groupByLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').groupByLimit;

admin/node_modules/sass-loader/node_modules/neo-async/groupBySeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').groupBySeries;

admin/node_modules/sass-loader/node_modules/neo-async/inject.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').inject;

admin/node_modules/sass-loader/node_modules/neo-async/iterator.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').iterator;

admin/node_modules/sass-loader/node_modules/neo-async/log.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').log;

admin/node_modules/sass-loader/node_modules/neo-async/map.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').map;

admin/node_modules/sass-loader/node_modules/neo-async/mapLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').mapLimit;

admin/node_modules/sass-loader/node_modules/neo-async/mapSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').mapSeries;

admin/node_modules/sass-loader/node_modules/neo-async/mapValues.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').mapValues;

admin/node_modules/sass-loader/node_modules/neo-async/mapValuesLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').mapValuesLimit;

admin/node_modules/sass-loader/node_modules/neo-async/mapValuesSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').mapValuesSeries;

admin/node_modules/sass-loader/node_modules/neo-async/memoize.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').memoize;

admin/node_modules/sass-loader/node_modules/neo-async/nextTick.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').nextTick;

admin/node_modules/sass-loader/node_modules/neo-async/omit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').omit;

admin/node_modules/sass-loader/node_modules/neo-async/omitLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').omitLimit;

admin/node_modules/sass-loader/node_modules/neo-async/omitSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').omitSeries;

admin/node_modules/sass-loader/node_modules/neo-async/package.json

@@ -1,89 +0,0 @@
-{
-  "_args": [
-    [
-      "neo-async@2.6.2",
-      "D:\\zhaogongxue\\crm\\template\\admin"
-    ]
-  ],
-  "_development": true,
-  "_from": "neo-async@2.6.2",
-  "_id": "neo-async@2.6.2",
-  "_inBundle": false,
-  "_integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==",
-  "_location": "/sass-loader/neo-async",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "neo-async@2.6.2",
-    "name": "neo-async",
-    "escapedName": "neo-async",
-    "rawSpec": "2.6.2",
-    "saveSpec": null,
-    "fetchSpec": "2.6.2"
-  },
-  "_requiredBy": [
-    "/sass-loader"
-  ],
-  "_resolved": "https://registry.npmmirror.com/neo-async/-/neo-async-2.6.2.tgz",
-  "_spec": "2.6.2",
-  "_where": "D:\\zhaogongxue\\crm\\template\\admin",
-  "browser": "async.min.js",
-  "bugs": {
-    "url": "https://github.com/suguru03/neo-async/issues"
-  },
-  "dependencies": {},
-  "description": "Neo-Async is a drop-in replacement for Async, it almost fully covers its functionality and runs faster ",
-  "devDependencies": {
-    "aigle": "^1.14.0",
-    "async": "^2.6.0",
-    "benchmark": "^2.1.1",
-    "bluebird": "^3.5.1",
-    "codecov.io": "^0.1.6",
-    "fs-extra": "^4.0.2",
-    "func-comparator": "^0.7.2",
-    "gulp": "^4.0.2",
-    "gulp-bump": "^2.8.0",
-    "gulp-exit": "0.0.2",
-    "gulp-git": "^2.4.2",
-    "gulp-jscs": "^4.0.0",
-    "gulp-mocha": "^4.2.0",
-    "gulp-tag-version": "^1.3.0",
-    "gulp-util": "^3.0.7",
-    "husky": "^1.2.0",
-    "istanbul": "^0.4.3",
-    "jsdoc": "^3.5.5",
-    "jshint": "^2.9.5",
-    "lint-staged": "^8.1.0",
-    "lodash": "^4.16.6",
-    "minimist": "^1.2.0",
-    "mocha": "^3.5.3",
-    "mocha-parallel-executor": "^0.3.0",
-    "mocha.parallel": "^0.15.3",
-    "prettier": "^1.15.2",
-    "require-dir": "^0.3.0"
-  },
-  "homepage": "https://github.com/suguru03/neo-async",
-  "keywords": [
-    "async",
-    "util"
-  ],
-  "license": "MIT",
-  "lint-staged": {
-    "*.{js,ts}": [
-      "prettier --write",
-      "git add"
-    ]
-  },
-  "main": "async.js",
-  "name": "neo-async",
-  "prettier": {
-    "printWidth": 100,
-    "singleQuote": true
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/suguru03/neo-async.git"
-  },
-  "version": "2.6.2"
-}

admin/node_modules/sass-loader/node_modules/neo-async/parallel.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').parallel;

admin/node_modules/sass-loader/node_modules/neo-async/parallelLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').parallelLimit;

admin/node_modules/sass-loader/node_modules/neo-async/pick.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').pick;

admin/node_modules/sass-loader/node_modules/neo-async/pickLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').pickLimit;

admin/node_modules/sass-loader/node_modules/neo-async/pickSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').pickSeries;

admin/node_modules/sass-loader/node_modules/neo-async/priorityQueue.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').priorityQueue;

admin/node_modules/sass-loader/node_modules/neo-async/queue.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').queue;

admin/node_modules/sass-loader/node_modules/neo-async/race.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').race;

admin/node_modules/sass-loader/node_modules/neo-async/reduce.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').reduce;

admin/node_modules/sass-loader/node_modules/neo-async/reduceRight.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').reduceRight;

admin/node_modules/sass-loader/node_modules/neo-async/reflect.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').reflect;

admin/node_modules/sass-loader/node_modules/neo-async/reflectAll.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').reflectAll;

admin/node_modules/sass-loader/node_modules/neo-async/reject.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').reject;

admin/node_modules/sass-loader/node_modules/neo-async/rejectLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').rejectLimit;

admin/node_modules/sass-loader/node_modules/neo-async/rejectSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').rejectSeries;

admin/node_modules/sass-loader/node_modules/neo-async/retry.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').retry;

admin/node_modules/sass-loader/node_modules/neo-async/retryable.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').retryable;

admin/node_modules/sass-loader/node_modules/neo-async/safe.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').safe;

admin/node_modules/sass-loader/node_modules/neo-async/select.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').select;

admin/node_modules/sass-loader/node_modules/neo-async/selectLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').selectLimit;

admin/node_modules/sass-loader/node_modules/neo-async/selectSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').selectSeries;

admin/node_modules/sass-loader/node_modules/neo-async/seq.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').seq;

admin/node_modules/sass-loader/node_modules/neo-async/series.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').series;

admin/node_modules/sass-loader/node_modules/neo-async/setImmediate.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').setImmediate;

admin/node_modules/sass-loader/node_modules/neo-async/some.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').some;

admin/node_modules/sass-loader/node_modules/neo-async/someLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').someLimit;

admin/node_modules/sass-loader/node_modules/neo-async/someSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').someSeries;

admin/node_modules/sass-loader/node_modules/neo-async/sortBy.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').sortBy;

admin/node_modules/sass-loader/node_modules/neo-async/sortByLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').sortByLimit;

admin/node_modules/sass-loader/node_modules/neo-async/sortBySeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').sortBySeries;

admin/node_modules/sass-loader/node_modules/neo-async/timeout.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').timeout;

admin/node_modules/sass-loader/node_modules/neo-async/times.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').times;

admin/node_modules/sass-loader/node_modules/neo-async/timesLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').timesLimit;

admin/node_modules/sass-loader/node_modules/neo-async/timesSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').timesSeries;

admin/node_modules/sass-loader/node_modules/neo-async/transform.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').transform;

admin/node_modules/sass-loader/node_modules/neo-async/transformLimit.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').transformLimit;

admin/node_modules/sass-loader/node_modules/neo-async/transformSeries.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').transformSeries;

admin/node_modules/sass-loader/node_modules/neo-async/tryEach.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').tryEach;

admin/node_modules/sass-loader/node_modules/neo-async/unmemoize.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').unmemoize;

admin/node_modules/sass-loader/node_modules/neo-async/until.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').until;

admin/node_modules/sass-loader/node_modules/neo-async/waterfall.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').waterfall;

admin/node_modules/sass-loader/node_modules/neo-async/whilst.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').whilst;

admin/node_modules/sass-loader/node_modules/neo-async/wrapSync.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./async').wrapSync;

admin/node_modules/sass-loader/node_modules/schema-utils/LICENSE

@@ -1,20 +0,0 @@
-Copyright JS Foundation and other contributors
-
-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.

admin/node_modules/sass-loader/node_modules/schema-utils/README.md

@@ -1,290 +0,0 @@
-<div align="center">
-  <a href="http://json-schema.org">
-    <img width="160" height="160"
-      src="https://raw.githubusercontent.com/webpack-contrib/schema-utils/master/.github/assets/logo.png">
-  </a>
-  <a href="https://github.com/webpack/webpack">
-    <img width="200" height="200"
-      src="https://webpack.js.org/assets/icon-square-big.svg">
-  </a>
-</div>
-
-[![npm][npm]][npm-url]
-[![node][node]][node-url]
-[![deps][deps]][deps-url]
-[![tests][tests]][tests-url]
-[![coverage][cover]][cover-url]
-[![chat][chat]][chat-url]
-[![size][size]][size-url]
-
-# schema-utils
-
-Package for validate options in loaders and plugins.
-
-## Getting Started
-
-To begin, you'll need to install `schema-utils`:
-
-```console
-npm install schema-utils
-```
-
-## API
-
-**schema.json**
-
-```json
-{
-  "type": "object",
-  "properties": {
-    "option": {
-      "type": "boolean"
-    }
-  },
-  "additionalProperties": false
-}
-```
-
-```js
-import schema from "./path/to/schema.json";
-import { validate } from "schema-utils";
-
-const options = { option: true };
-const configuration = { name: "Loader Name/Plugin Name/Name" };
-
-validate(schema, options, configuration);
-```
-
-### `schema`
-
-Type: `String`
-
-JSON schema.
-
-Simple example of schema:
-
-```json
-{
-  "type": "object",
-  "properties": {
-    "name": {
-      "description": "This is description of option.",
-      "type": "string"
-    }
-  },
-  "additionalProperties": false
-}
-```
-
-### `options`
-
-Type: `Object`
-
-Object with options.
-
-```js
-import schema from "./path/to/schema.json";
-import { validate } from "schema-utils";
-
-const options = { foo: "bar" };
-
-validate(schema, { name: 123 }, { name: "MyPlugin" });
-```
-
-### `configuration`
-
-Allow to configure validator.
-
-There is an alternative method to configure the `name` and`baseDataPath` options via the `title` property in the schema.
-For example:
-
-```json
-{
-  "title": "My Loader options",
-  "type": "object",
-  "properties": {
-    "name": {
-      "description": "This is description of option.",
-      "type": "string"
-    }
-  },
-  "additionalProperties": false
-}
-```
-
-The last word used for the `baseDataPath` option, other words used for the `name` option.
-Based on the example above the `name` option equals `My Loader`, the `baseDataPath` option equals `options`.
-
-#### `name`
-
-Type: `Object`
-Default: `"Object"`
-
-Allow to setup name in validation errors.
-
-```js
-import schema from "./path/to/schema.json";
-import { validate } from "schema-utils";
-
-const options = { foo: "bar" };
-
-validate(schema, options, { name: "MyPlugin" });
-```
-
-```shell
-Invalid configuration object. MyPlugin has been initialised using a configuration object that does not match the API schema.
- - configuration.optionName should be a integer.
-```
-
-#### `baseDataPath`
-
-Type: `String`
-Default: `"configuration"`
-
-Allow to setup base data path in validation errors.
-
-```js
-import schema from "./path/to/schema.json";
-import { validate } from "schema-utils";
-
-const options = { foo: "bar" };
-
-validate(schema, options, { name: "MyPlugin", baseDataPath: "options" });
-```
-
-```shell
-Invalid options object. MyPlugin has been initialised using an options object that does not match the API schema.
- - options.optionName should be a integer.
-```
-
-#### `postFormatter`
-
-Type: `Function`
-Default: `undefined`
-
-Allow to reformat errors.
-
-```js
-import schema from "./path/to/schema.json";
-import { validate } from "schema-utils";
-
-const options = { foo: "bar" };
-
-validate(schema, options, {
-  name: "MyPlugin",
-  postFormatter: (formattedError, error) => {
-    if (error.keyword === "type") {
-      return `${formattedError}\nAdditional Information.`;
-    }
-
-    return formattedError;
-  },
-});
-```
-
-```shell
-Invalid options object. MyPlugin has been initialized using an options object that does not match the API schema.
- - options.optionName should be a integer.
-   Additional Information.
-```
-
-## Examples
-
-**schema.json**
-
-```json
-{
-  "type": "object",
-  "properties": {
-    "name": {
-      "type": "string"
-    },
-    "test": {
-      "anyOf": [
-        { "type": "array" },
-        { "type": "string" },
-        { "instanceof": "RegExp" }
-      ]
-    },
-    "transform": {
-      "instanceof": "Function"
-    },
-    "sourceMap": {
-      "type": "boolean"
-    }
-  },
-  "additionalProperties": false
-}
-```
-
-### `Loader`
-
-```js
-import { getOptions } from "loader-utils";
-import { validate } from "schema-utils";
-
-import schema from "path/to/schema.json";
-
-function loader(src, map) {
-  const options = getOptions(this);
-
-  validate(schema, options, {
-    name: "Loader Name",
-    baseDataPath: "options",
-  });
-
-  // Code...
-}
-
-export default loader;
-```
-
-### `Plugin`
-
-```js
-import { validate } from "schema-utils";
-
-import schema from "path/to/schema.json";
-
-class Plugin {
-  constructor(options) {
-    validate(schema, options, {
-      name: "Plugin Name",
-      baseDataPath: "options",
-    });
-
-    this.options = options;
-  }
-
-  apply(compiler) {
-    // Code...
-  }
-}
-
-export default Plugin;
-```
-
-## Contributing
-
-Please take a moment to read our contributing guidelines if you haven't yet done so.
-
-[CONTRIBUTING](./.github/CONTRIBUTING.md)
-
-## License
-
-[MIT](./LICENSE)
-
-[npm]: https://img.shields.io/npm/v/schema-utils.svg
-[npm-url]: https://npmjs.com/package/schema-utils
-[node]: https://img.shields.io/node/v/schema-utils.svg
-[node-url]: https://nodejs.org
-[deps]: https://david-dm.org/webpack/schema-utils.svg
-[deps-url]: https://david-dm.org/webpack/schema-utils
-[tests]: https://github.com/webpack/schema-utils/workflows/schema-utils/badge.svg
-[tests-url]: https://github.com/webpack/schema-utils/actions
-[cover]: https://codecov.io/gh/webpack/schema-utils/branch/master/graph/badge.svg
-[cover-url]: https://codecov.io/gh/webpack/schema-utils
-[chat]: https://badges.gitter.im/webpack/webpack.svg
-[chat-url]: https://gitter.im/webpack/webpack
-[size]: https://packagephobia.com/badge?p=schema-utils
-[size-url]: https://packagephobia.com/result?p=schema-utils

admin/node_modules/sass-loader/node_modules/schema-utils/declarations/ValidationError.d.ts

@@ -1,74 +0,0 @@
-export default ValidationError;
-export type JSONSchema6 = import("json-schema").JSONSchema6;
-export type JSONSchema7 = import("json-schema").JSONSchema7;
-export type Schema = import("./validate").Schema;
-export type ValidationErrorConfiguration =
-  import("./validate").ValidationErrorConfiguration;
-export type PostFormatter = import("./validate").PostFormatter;
-export type SchemaUtilErrorObject = import("./validate").SchemaUtilErrorObject;
-declare class ValidationError extends Error {
-  /**
-   * @param {Array<SchemaUtilErrorObject>} errors
-   * @param {Schema} schema
-   * @param {ValidationErrorConfiguration} configuration
-   */
-  constructor(
-    errors: Array<SchemaUtilErrorObject>,
-    schema: Schema,
-    configuration?: ValidationErrorConfiguration
-  );
-  /** @type {Array<SchemaUtilErrorObject>} */
-  errors: Array<SchemaUtilErrorObject>;
-  /** @type {Schema} */
-  schema: Schema;
-  /** @type {string} */
-  headerName: string;
-  /** @type {string} */
-  baseDataPath: string;
-  /** @type {PostFormatter | null} */
-  postFormatter: PostFormatter | null;
-  /**
-   * @param {string} path
-   * @returns {Schema}
-   */
-  getSchemaPart(path: string): Schema;
-  /**
-   * @param {Schema} schema
-   * @param {boolean} logic
-   * @param {Array<Object>} prevSchemas
-   * @returns {string}
-   */
-  formatSchema(
-    schema: Schema,
-    logic?: boolean,
-    prevSchemas?: Array<Object>
-  ): string;
-  /**
-   * @param {Schema=} schemaPart
-   * @param {(boolean | Array<string>)=} additionalPath
-   * @param {boolean=} needDot
-   * @param {boolean=} logic
-   * @returns {string}
-   */
-  getSchemaPartText(
-    schemaPart?: Schema | undefined,
-    additionalPath?: (boolean | Array<string>) | undefined,
-    needDot?: boolean | undefined,
-    logic?: boolean | undefined
-  ): string;
-  /**
-   * @param {Schema=} schemaPart
-   * @returns {string}
-   */
-  getSchemaPartDescription(schemaPart?: Schema | undefined): string;
-  /**
-   * @param {SchemaUtilErrorObject} error
-   * @returns {string}
-   */
-  formatValidationError(error: SchemaUtilErrorObject): string;
-  /**
-   * @param {Array<SchemaUtilErrorObject>} errors
-   * @returns {string}
-   */
-  formatValidationErrors(errors: Array<SchemaUtilErrorObject>): string;
-}

admin/node_modules/sass-loader/node_modules/schema-utils/declarations/index.d.ts

@@ -1,3 +0,0 @@
-import { validate } from "./validate";
-import { ValidationError } from "./validate";
-export { validate, ValidationError };

admin/node_modules/sass-loader/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts

@@ -1,10 +0,0 @@
-export default addAbsolutePathKeyword;
-export type Ajv = import("ajv").Ajv;
-export type ValidateFunction = import("ajv").ValidateFunction;
-export type SchemaUtilErrorObject = import("../validate").SchemaUtilErrorObject;
-/**
- *
- * @param {Ajv} ajv
- * @returns {Ajv}
- */
-declare function addAbsolutePathKeyword(ajv: Ajv): Ajv;

admin/node_modules/sass-loader/node_modules/schema-utils/declarations/util/Range.d.ts

@@ -1,79 +0,0 @@
-export = Range;
-/**
- * @typedef {[number, boolean]} RangeValue
- */
-/**
- * @callback RangeValueCallback
- * @param {RangeValue} rangeValue
- * @returns {boolean}
- */
-declare class Range {
-  /**
-   * @param {"left" | "right"} side
-   * @param {boolean} exclusive
-   * @returns {">" | ">=" | "<" | "<="}
-   */
-  static getOperator(
-    side: "left" | "right",
-    exclusive: boolean
-  ): ">" | ">=" | "<" | "<=";
-  /**
-   * @param {number} value
-   * @param {boolean} logic is not logic applied
-   * @param {boolean} exclusive is range exclusive
-   * @returns {string}
-   */
-  static formatRight(value: number, logic: boolean, exclusive: boolean): string;
-  /**
-   * @param {number} value
-   * @param {boolean} logic is not logic applied
-   * @param {boolean} exclusive is range exclusive
-   * @returns {string}
-   */
-  static formatLeft(value: number, logic: boolean, exclusive: boolean): string;
-  /**
-   * @param {number} start left side value
-   * @param {number} end right side value
-   * @param {boolean} startExclusive is range exclusive from left side
-   * @param {boolean} endExclusive is range exclusive from right side
-   * @param {boolean} logic is not logic applied
-   * @returns {string}
-   */
-  static formatRange(
-    start: number,
-    end: number,
-    startExclusive: boolean,
-    endExclusive: boolean,
-    logic: boolean
-  ): string;
-  /**
-   * @param {Array<RangeValue>} values
-   * @param {boolean} logic is not logic applied
-   * @return {RangeValue} computed value and it's exclusive flag
-   */
-  static getRangeValue(values: Array<RangeValue>, logic: boolean): RangeValue;
-  /** @type {Array<RangeValue>} */
-  _left: Array<RangeValue>;
-  /** @type {Array<RangeValue>} */
-  _right: Array<RangeValue>;
-  /**
-   * @param {number} value
-   * @param {boolean=} exclusive
-   */
-  left(value: number, exclusive?: boolean | undefined): void;
-  /**
-   * @param {number} value
-   * @param {boolean=} exclusive
-   */
-  right(value: number, exclusive?: boolean | undefined): void;
-  /**
-   * @param {boolean} logic is not logic applied
-   * @return {string} "smart" range string representation
-   */
-  format(logic?: boolean): string;
-}
-declare namespace Range {
-  export { RangeValue, RangeValueCallback };
-}
-type RangeValue = [number, boolean];
-type RangeValueCallback = (rangeValue: RangeValue) => boolean;

admin/node_modules/sass-loader/node_modules/schema-utils/declarations/util/hints.d.ts

@@ -1,3 +0,0 @@
-export function stringHints(schema: Schema, logic: boolean): string[];
-export function numberHints(schema: Schema, logic: boolean): string[];
-export type Schema = import("../validate").Schema;

admin/node_modules/sass-loader/node_modules/schema-utils/declarations/validate.d.ts

@@ -1,37 +0,0 @@
-export type JSONSchema4 = import("json-schema").JSONSchema4;
-export type JSONSchema6 = import("json-schema").JSONSchema6;
-export type JSONSchema7 = import("json-schema").JSONSchema7;
-export type ErrorObject = import("ajv").ErrorObject;
-export type Extend = {
-  formatMinimum?: number | undefined;
-  formatMaximum?: number | undefined;
-  formatExclusiveMinimum?: boolean | undefined;
-  formatExclusiveMaximum?: boolean | undefined;
-  link?: string | undefined;
-};
-export type Schema = (JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend;
-export type SchemaUtilErrorObject = ErrorObject & {
-  children?: Array<ErrorObject>;
-};
-export type PostFormatter = (
-  formattedError: string,
-  error: SchemaUtilErrorObject
-) => string;
-export type ValidationErrorConfiguration = {
-  name?: string | undefined;
-  baseDataPath?: string | undefined;
-  postFormatter?: PostFormatter | undefined;
-};
-/**
- * @param {Schema} schema
- * @param {Array<object> | object} options
- * @param {ValidationErrorConfiguration=} configuration
- * @returns {void}
- */
-export function validate(
-  schema: Schema,
-  options: Array<object> | object,
-  configuration?: ValidationErrorConfiguration | undefined
-): void;
-import ValidationError from "./ValidationError";
-export { ValidationError };

admin/node_modules/sass-loader/node_modules/schema-utils/dist/ValidationError.js

@@ -1,1271 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-const {
-  stringHints,
-  numberHints
-} = require("./util/hints");
-/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
-
-/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
-
-/** @typedef {import("./validate").Schema} Schema */
-
-/** @typedef {import("./validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
-
-/** @typedef {import("./validate").PostFormatter} PostFormatter */
-
-/** @typedef {import("./validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
-
-/** @enum {number} */
-
-
-const SPECIFICITY = {
-  type: 1,
-  not: 1,
-  oneOf: 1,
-  anyOf: 1,
-  if: 1,
-  enum: 1,
-  const: 1,
-  instanceof: 1,
-  required: 2,
-  pattern: 2,
-  patternRequired: 2,
-  format: 2,
-  formatMinimum: 2,
-  formatMaximum: 2,
-  minimum: 2,
-  exclusiveMinimum: 2,
-  maximum: 2,
-  exclusiveMaximum: 2,
-  multipleOf: 2,
-  uniqueItems: 2,
-  contains: 2,
-  minLength: 2,
-  maxLength: 2,
-  minItems: 2,
-  maxItems: 2,
-  minProperties: 2,
-  maxProperties: 2,
-  dependencies: 2,
-  propertyNames: 2,
-  additionalItems: 2,
-  additionalProperties: 2,
-  absolutePath: 2
-};
-/**
- *
- * @param {Array<SchemaUtilErrorObject>} array
- * @param {(item: SchemaUtilErrorObject) => number} fn
- * @returns {Array<SchemaUtilErrorObject>}
- */
-
-function filterMax(array, fn) {
-  const evaluatedMax = array.reduce((max, item) => Math.max(max, fn(item)), 0);
-  return array.filter(item => fn(item) === evaluatedMax);
-}
-/**
- *
- * @param {Array<SchemaUtilErrorObject>} children
- * @returns {Array<SchemaUtilErrorObject>}
- */
-
-
-function filterChildren(children) {
-  let newChildren = children;
-  newChildren = filterMax(newChildren,
-  /**
-   *
-   * @param {SchemaUtilErrorObject} error
-   * @returns {number}
-   */
-  error => error.dataPath ? error.dataPath.length : 0);
-  newChildren = filterMax(newChildren,
-  /**
-   * @param {SchemaUtilErrorObject} error
-   * @returns {number}
-   */
-  error => SPECIFICITY[
-  /** @type {keyof typeof SPECIFICITY} */
-  error.keyword] || 2);
-  return newChildren;
-}
-/**
- * Find all children errors
- * @param {Array<SchemaUtilErrorObject>} children
- * @param {Array<string>} schemaPaths
- * @return {number} returns index of first child
- */
-
-
-function findAllChildren(children, schemaPaths) {
-  let i = children.length - 1;
-
-  const predicate =
-  /**
-   * @param {string} schemaPath
-   * @returns {boolean}
-   */
-  schemaPath => children[i].schemaPath.indexOf(schemaPath) !== 0;
-
-  while (i > -1 && !schemaPaths.every(predicate)) {
-    if (children[i].keyword === "anyOf" || children[i].keyword === "oneOf") {
-      const refs = extractRefs(children[i]);
-      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(children[i].schemaPath));
-      i = childrenStart - 1;
-    } else {
-      i -= 1;
-    }
-  }
-
-  return i + 1;
-}
-/**
- * Extracts all refs from schema
- * @param {SchemaUtilErrorObject} error
- * @return {Array<string>}
- */
-
-
-function extractRefs(error) {
-  const {
-    schema
-  } = error;
-
-  if (!Array.isArray(schema)) {
-    return [];
-  }
-
-  return schema.map(({
-    $ref
-  }) => $ref).filter(s => s);
-}
-/**
- * Groups children by their first level parent (assuming that error is root)
- * @param {Array<SchemaUtilErrorObject>} children
- * @return {Array<SchemaUtilErrorObject>}
- */
-
-
-function groupChildrenByFirstChild(children) {
-  const result = [];
-  let i = children.length - 1;
-
-  while (i > 0) {
-    const child = children[i];
-
-    if (child.keyword === "anyOf" || child.keyword === "oneOf") {
-      const refs = extractRefs(child);
-      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(child.schemaPath));
-
-      if (childrenStart !== i) {
-        result.push(Object.assign({}, child, {
-          children: children.slice(childrenStart, i)
-        }));
-        i = childrenStart;
-      } else {
-        result.push(child);
-      }
-    } else {
-      result.push(child);
-    }
-
-    i -= 1;
-  }
-
-  if (i === 0) {
-    result.push(children[i]);
-  }
-
-  return result.reverse();
-}
-/**
- * @param {string} str
- * @param {string} prefix
- * @returns {string}
- */
-
-
-function indent(str, prefix) {
-  return str.replace(/\n(?!$)/g, `\n${prefix}`);
-}
-/**
- * @param {Schema} schema
- * @returns {schema is (Schema & {not: Schema})}
- */
-
-
-function hasNotInSchema(schema) {
-  return !!schema.not;
-}
-/**
- * @param {Schema} schema
- * @return {Schema}
- */
-
-
-function findFirstTypedSchema(schema) {
-  if (hasNotInSchema(schema)) {
-    return findFirstTypedSchema(schema.not);
-  }
-
-  return schema;
-}
-/**
- * @param {Schema} schema
- * @return {boolean}
- */
-
-
-function canApplyNot(schema) {
-  const typedSchema = findFirstTypedSchema(schema);
-  return likeNumber(typedSchema) || likeInteger(typedSchema) || likeString(typedSchema) || likeNull(typedSchema) || likeBoolean(typedSchema);
-}
-/**
- * @param {any} maybeObj
- * @returns {boolean}
- */
-
-
-function isObject(maybeObj) {
-  return typeof maybeObj === "object" && maybeObj !== null;
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
-
-
-function likeNumber(schema) {
-  return schema.type === "number" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
-
-
-function likeInteger(schema) {
-  return schema.type === "integer" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
-
-
-function likeString(schema) {
-  return schema.type === "string" || typeof schema.minLength !== "undefined" || typeof schema.maxLength !== "undefined" || typeof schema.pattern !== "undefined" || typeof schema.format !== "undefined" || typeof schema.formatMinimum !== "undefined" || typeof schema.formatMaximum !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
-
-
-function likeBoolean(schema) {
-  return schema.type === "boolean";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
-
-
-function likeArray(schema) {
-  return schema.type === "array" || typeof schema.minItems === "number" || typeof schema.maxItems === "number" || typeof schema.uniqueItems !== "undefined" || typeof schema.items !== "undefined" || typeof schema.additionalItems !== "undefined" || typeof schema.contains !== "undefined";
-}
-/**
- * @param {Schema & {patternRequired?: Array<string>}} schema
- * @returns {boolean}
- */
-
-
-function likeObject(schema) {
-  return schema.type === "object" || typeof schema.minProperties !== "undefined" || typeof schema.maxProperties !== "undefined" || typeof schema.required !== "undefined" || typeof schema.properties !== "undefined" || typeof schema.patternProperties !== "undefined" || typeof schema.additionalProperties !== "undefined" || typeof schema.dependencies !== "undefined" || typeof schema.propertyNames !== "undefined" || typeof schema.patternRequired !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
-
-
-function likeNull(schema) {
-  return schema.type === "null";
-}
-/**
- * @param {string} type
- * @returns {string}
- */
-
-
-function getArticle(type) {
-  if (/^[aeiou]/i.test(type)) {
-    return "an";
-  }
-
-  return "a";
-}
-/**
- * @param {Schema=} schema
- * @returns {string}
- */
-
-
-function getSchemaNonTypes(schema) {
-  if (!schema) {
-    return "";
-  }
-
-  if (!schema.type) {
-    if (likeNumber(schema) || likeInteger(schema)) {
-      return " | should be any non-number";
-    }
-
-    if (likeString(schema)) {
-      return " | should be any non-string";
-    }
-
-    if (likeArray(schema)) {
-      return " | should be any non-array";
-    }
-
-    if (likeObject(schema)) {
-      return " | should be any non-object";
-    }
-  }
-
-  return "";
-}
-/**
- * @param {Array<string>} hints
- * @returns {string}
- */
-
-
-function formatHints(hints) {
-  return hints.length > 0 ? `(${hints.join(", ")})` : "";
-}
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @returns {string[]}
- */
-
-
-function getHints(schema, logic) {
-  if (likeNumber(schema) || likeInteger(schema)) {
-    return numberHints(schema, logic);
-  } else if (likeString(schema)) {
-    return stringHints(schema, logic);
-  }
-
-  return [];
-}
-
-class ValidationError extends Error {
-  /**
-   * @param {Array<SchemaUtilErrorObject>} errors
-   * @param {Schema} schema
-   * @param {ValidationErrorConfiguration} configuration
-   */
-  constructor(errors, schema, configuration = {}) {
-    super();
-    /** @type {string} */
-
-    this.name = "ValidationError";
-    /** @type {Array<SchemaUtilErrorObject>} */
-
-    this.errors = errors;
-    /** @type {Schema} */
-
-    this.schema = schema;
-    let headerNameFromSchema;
-    let baseDataPathFromSchema;
-
-    if (schema.title && (!configuration.name || !configuration.baseDataPath)) {
-      const splittedTitleFromSchema = schema.title.match(/^(.+) (.+)$/);
-
-      if (splittedTitleFromSchema) {
-        if (!configuration.name) {
-          [, headerNameFromSchema] = splittedTitleFromSchema;
-        }
-
-        if (!configuration.baseDataPath) {
-          [,, baseDataPathFromSchema] = splittedTitleFromSchema;
-        }
-      }
-    }
-    /** @type {string} */
-
-
-    this.headerName = configuration.name || headerNameFromSchema || "Object";
-    /** @type {string} */
-
-    this.baseDataPath = configuration.baseDataPath || baseDataPathFromSchema || "configuration";
-    /** @type {PostFormatter | null} */
-
-    this.postFormatter = configuration.postFormatter || null;
-    const header = `Invalid ${this.baseDataPath} object. ${this.headerName} has been initialized using ${getArticle(this.baseDataPath)} ${this.baseDataPath} object that does not match the API schema.\n`;
-    /** @type {string} */
-
-    this.message = `${header}${this.formatValidationErrors(errors)}`;
-    Error.captureStackTrace(this, this.constructor);
-  }
-  /**
-   * @param {string} path
-   * @returns {Schema}
-   */
-
-
-  getSchemaPart(path) {
-    const newPath = path.split("/");
-    let schemaPart = this.schema;
-
-    for (let i = 1; i < newPath.length; i++) {
-      const inner = schemaPart[
-      /** @type {keyof Schema} */
-      newPath[i]];
-
-      if (!inner) {
-        break;
-      }
-
-      schemaPart = inner;
-    }
-
-    return schemaPart;
-  }
-  /**
-   * @param {Schema} schema
-   * @param {boolean} logic
-   * @param {Array<Object>} prevSchemas
-   * @returns {string}
-   */
-
-
-  formatSchema(schema, logic = true, prevSchemas = []) {
-    let newLogic = logic;
-
-    const formatInnerSchema =
-    /**
-     *
-     * @param {Object} innerSchema
-     * @param {boolean=} addSelf
-     * @returns {string}
-     */
-    (innerSchema, addSelf) => {
-      if (!addSelf) {
-        return this.formatSchema(innerSchema, newLogic, prevSchemas);
-      }
-
-      if (prevSchemas.includes(innerSchema)) {
-        return "(recursive)";
-      }
-
-      return this.formatSchema(innerSchema, newLogic, prevSchemas.concat(schema));
-    };
-
-    if (hasNotInSchema(schema) && !likeObject(schema)) {
-      if (canApplyNot(schema.not)) {
-        newLogic = !logic;
-        return formatInnerSchema(schema.not);
-      }
-
-      const needApplyLogicHere = !schema.not.not;
-      const prefix = logic ? "" : "non ";
-      newLogic = !logic;
-      return needApplyLogicHere ? prefix + formatInnerSchema(schema.not) : formatInnerSchema(schema.not);
-    }
-
-    if (
-    /** @type {Schema & {instanceof: string | Array<string>}} */
-    schema.instanceof) {
-      const {
-        instanceof: value
-      } =
-      /** @type {Schema & {instanceof: string | Array<string>}} */
-      schema;
-      const values = !Array.isArray(value) ? [value] : value;
-      return values.map(
-      /**
-       * @param {string} item
-       * @returns {string}
-       */
-      item => item === "Function" ? "function" : item).join(" | ");
-    }
-
-    if (schema.enum) {
-      return (
-        /** @type {Array<any>} */
-        schema.enum.map(item => JSON.stringify(item)).join(" | ")
-      );
-    }
-
-    if (typeof schema.const !== "undefined") {
-      return JSON.stringify(schema.const);
-    }
-
-    if (schema.oneOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.oneOf.map(item => formatInnerSchema(item, true)).join(" | ")
-      );
-    }
-
-    if (schema.anyOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.anyOf.map(item => formatInnerSchema(item, true)).join(" | ")
-      );
-    }
-
-    if (schema.allOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.allOf.map(item => formatInnerSchema(item, true)).join(" & ")
-      );
-    }
-
-    if (
-    /** @type {JSONSchema7} */
-    schema.if) {
-      const {
-        if: ifValue,
-        then: thenValue,
-        else: elseValue
-      } =
-      /** @type {JSONSchema7} */
-      schema;
-      return `${ifValue ? `if ${formatInnerSchema(ifValue)}` : ""}${thenValue ? ` then ${formatInnerSchema(thenValue)}` : ""}${elseValue ? ` else ${formatInnerSchema(elseValue)}` : ""}`;
-    }
-
-    if (schema.$ref) {
-      return formatInnerSchema(this.getSchemaPart(schema.$ref), true);
-    }
-
-    if (likeNumber(schema) || likeInteger(schema)) {
-      const [type, ...hints] = getHints(schema, logic);
-      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
-      return logic ? str : hints.length > 0 ? `non-${type} | ${str}` : `non-${type}`;
-    }
-
-    if (likeString(schema)) {
-      const [type, ...hints] = getHints(schema, logic);
-      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
-      return logic ? str : str === "string" ? "non-string" : `non-string | ${str}`;
-    }
-
-    if (likeBoolean(schema)) {
-      return `${logic ? "" : "non-"}boolean`;
-    }
-
-    if (likeArray(schema)) {
-      // not logic already applied in formatValidationError
-      newLogic = true;
-      const hints = [];
-
-      if (typeof schema.minItems === "number") {
-        hints.push(`should not have fewer than ${schema.minItems} item${schema.minItems > 1 ? "s" : ""}`);
-      }
-
-      if (typeof schema.maxItems === "number") {
-        hints.push(`should not have more than ${schema.maxItems} item${schema.maxItems > 1 ? "s" : ""}`);
-      }
-
-      if (schema.uniqueItems) {
-        hints.push("should not have duplicate items");
-      }
-
-      const hasAdditionalItems = typeof schema.additionalItems === "undefined" || Boolean(schema.additionalItems);
-      let items = "";
-
-      if (schema.items) {
-        if (Array.isArray(schema.items) && schema.items.length > 0) {
-          items = `${
-          /** @type {Array<Schema>} */
-          schema.items.map(item => formatInnerSchema(item)).join(", ")}`;
-
-          if (hasAdditionalItems) {
-            if (schema.additionalItems && isObject(schema.additionalItems) && Object.keys(schema.additionalItems).length > 0) {
-              hints.push(`additional items should be ${formatInnerSchema(schema.additionalItems)}`);
-            }
-          }
-        } else if (schema.items && Object.keys(schema.items).length > 0) {
-          // "additionalItems" is ignored
-          items = `${formatInnerSchema(schema.items)}`;
-        } else {
-          // Fallback for empty `items` value
-          items = "any";
-        }
-      } else {
-        // "additionalItems" is ignored
-        items = "any";
-      }
-
-      if (schema.contains && Object.keys(schema.contains).length > 0) {
-        hints.push(`should contains at least one ${this.formatSchema(schema.contains)} item`);
-      }
-
-      return `[${items}${hasAdditionalItems ? ", ..." : ""}]${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
-    }
-
-    if (likeObject(schema)) {
-      // not logic already applied in formatValidationError
-      newLogic = true;
-      const hints = [];
-
-      if (typeof schema.minProperties === "number") {
-        hints.push(`should not have fewer than ${schema.minProperties} ${schema.minProperties > 1 ? "properties" : "property"}`);
-      }
-
-      if (typeof schema.maxProperties === "number") {
-        hints.push(`should not have more than ${schema.maxProperties} ${schema.minProperties && schema.minProperties > 1 ? "properties" : "property"}`);
-      }
-
-      if (schema.patternProperties && Object.keys(schema.patternProperties).length > 0) {
-        const patternProperties = Object.keys(schema.patternProperties);
-        hints.push(`additional property names should match pattern${patternProperties.length > 1 ? "s" : ""} ${patternProperties.map(pattern => JSON.stringify(pattern)).join(" | ")}`);
-      }
-
-      const properties = schema.properties ? Object.keys(schema.properties) : [];
-      const required = schema.required ? schema.required : [];
-      const allProperties = [...new Set(
-      /** @type {Array<string>} */
-      [].concat(required).concat(properties))];
-      const objectStructure = allProperties.map(property => {
-        const isRequired = required.includes(property); // Some properties need quotes, maybe we should add check
-        // Maybe we should output type of property (`foo: string`), but it is looks very unreadable
-
-        return `${property}${isRequired ? "" : "?"}`;
-      }).concat(typeof schema.additionalProperties === "undefined" || Boolean(schema.additionalProperties) ? schema.additionalProperties && isObject(schema.additionalProperties) ? [`<key>: ${formatInnerSchema(schema.additionalProperties)}`] : ["…"] : []).join(", ");
-      const {
-        dependencies,
-        propertyNames,
-        patternRequired
-      } =
-      /** @type {Schema & {patternRequired?: Array<string>;}} */
-      schema;
-
-      if (dependencies) {
-        Object.keys(dependencies).forEach(dependencyName => {
-          const dependency = dependencies[dependencyName];
-
-          if (Array.isArray(dependency)) {
-            hints.push(`should have ${dependency.length > 1 ? "properties" : "property"} ${dependency.map(dep => `'${dep}'`).join(", ")} when property '${dependencyName}' is present`);
-          } else {
-            hints.push(`should be valid according to the schema ${formatInnerSchema(dependency)} when property '${dependencyName}' is present`);
-          }
-        });
-      }
-
-      if (propertyNames && Object.keys(propertyNames).length > 0) {
-        hints.push(`each property name should match format ${JSON.stringify(schema.propertyNames.format)}`);
-      }
-
-      if (patternRequired && patternRequired.length > 0) {
-        hints.push(`should have property matching pattern ${patternRequired.map(
-        /**
-         * @param {string} item
-         * @returns {string}
-         */
-        item => JSON.stringify(item))}`);
-      }
-
-      return `object {${objectStructure ? ` ${objectStructure} ` : ""}}${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
-    }
-
-    if (likeNull(schema)) {
-      return `${logic ? "" : "non-"}null`;
-    }
-
-    if (Array.isArray(schema.type)) {
-      // not logic already applied in formatValidationError
-      return `${schema.type.join(" | ")}`;
-    } // Fallback for unknown keywords
-    // not logic already applied in formatValidationError
-
-    /* istanbul ignore next */
-
-
-    return JSON.stringify(schema, null, 2);
-  }
-  /**
-   * @param {Schema=} schemaPart
-   * @param {(boolean | Array<string>)=} additionalPath
-   * @param {boolean=} needDot
-   * @param {boolean=} logic
-   * @returns {string}
-   */
-
-
-  getSchemaPartText(schemaPart, additionalPath, needDot = false, logic = true) {
-    if (!schemaPart) {
-      return "";
-    }
-
-    if (Array.isArray(additionalPath)) {
-      for (let i = 0; i < additionalPath.length; i++) {
-        /** @type {Schema | undefined} */
-        const inner = schemaPart[
-        /** @type {keyof Schema} */
-        additionalPath[i]];
-
-        if (inner) {
-          // eslint-disable-next-line no-param-reassign
-          schemaPart = inner;
-        } else {
-          break;
-        }
-      }
-    }
-
-    while (schemaPart.$ref) {
-      // eslint-disable-next-line no-param-reassign
-      schemaPart = this.getSchemaPart(schemaPart.$ref);
-    }
-
-    let schemaText = `${this.formatSchema(schemaPart, logic)}${needDot ? "." : ""}`;
-
-    if (schemaPart.description) {
-      schemaText += `\n-> ${schemaPart.description}`;
-    }
-
-    if (schemaPart.link) {
-      schemaText += `\n-> Read more at ${schemaPart.link}`;
-    }
-
-    return schemaText;
-  }
-  /**
-   * @param {Schema=} schemaPart
-   * @returns {string}
-   */
-
-
-  getSchemaPartDescription(schemaPart) {
-    if (!schemaPart) {
-      return "";
-    }
-
-    while (schemaPart.$ref) {
-      // eslint-disable-next-line no-param-reassign
-      schemaPart = this.getSchemaPart(schemaPart.$ref);
-    }
-
-    let schemaText = "";
-
-    if (schemaPart.description) {
-      schemaText += `\n-> ${schemaPart.description}`;
-    }
-
-    if (schemaPart.link) {
-      schemaText += `\n-> Read more at ${schemaPart.link}`;
-    }
-
-    return schemaText;
-  }
-  /**
-   * @param {SchemaUtilErrorObject} error
-   * @returns {string}
-   */
-
-
-  formatValidationError(error) {
-    const {
-      keyword,
-      dataPath: errorDataPath
-    } = error;
-    const dataPath = `${this.baseDataPath}${errorDataPath}`;
-
-    switch (keyword) {
-      case "type":
-        {
-          const {
-            parentSchema,
-            params
-          } = error; // eslint-disable-next-line default-case
-
-          switch (
-          /** @type {import("ajv").TypeParams} */
-          params.type) {
-            case "number":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
-
-            case "integer":
-              return `${dataPath} should be an ${this.getSchemaPartText(parentSchema, false, true)}`;
-
-            case "string":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
-
-            case "boolean":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
-
-            case "array":
-              return `${dataPath} should be an array:\n${this.getSchemaPartText(parentSchema)}`;
-
-            case "object":
-              return `${dataPath} should be an object:\n${this.getSchemaPartText(parentSchema)}`;
-
-            case "null":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
-
-            default:
-              return `${dataPath} should be:\n${this.getSchemaPartText(parentSchema)}`;
-          }
-        }
-
-      case "instanceof":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should be an instance of ${this.getSchemaPartText(parentSchema, false, true)}`;
-        }
-
-      case "pattern":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            pattern
-          } =
-          /** @type {import("ajv").PatternParams} */
-          params;
-          return `${dataPath} should match pattern ${JSON.stringify(pattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "format":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            format
-          } =
-          /** @type {import("ajv").FormatParams} */
-          params;
-          return `${dataPath} should match format ${JSON.stringify(format)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "formatMinimum":
-      case "formatMaximum":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            comparison,
-            limit
-          } =
-          /** @type {import("ajv").ComparisonParams} */
-          params;
-          return `${dataPath} should be ${comparison} ${JSON.stringify(limit)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "minimum":
-      case "maximum":
-      case "exclusiveMinimum":
-      case "exclusiveMaximum":
-        {
-          const {
-            parentSchema,
-            params
-          } = error;
-          const {
-            comparison,
-            limit
-          } =
-          /** @type {import("ajv").ComparisonParams} */
-          params;
-          const [, ...hints] = getHints(
-          /** @type {Schema} */
-          parentSchema, true);
-
-          if (hints.length === 0) {
-            hints.push(`should be ${comparison} ${limit}`);
-          }
-
-          return `${dataPath} ${hints.join(" ")}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "multipleOf":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            multipleOf
-          } =
-          /** @type {import("ajv").MultipleOfParams} */
-          params;
-          return `${dataPath} should be multiple of ${multipleOf}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "patternRequired":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            missingPattern
-          } =
-          /** @type {import("ajv").PatternRequiredParams} */
-          params;
-          return `${dataPath} should have property matching pattern ${JSON.stringify(missingPattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "minLength":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty string${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
-
-          const length = limit - 1;
-          return `${dataPath} should be longer than ${length} character${length > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "minItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty array${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
-
-          return `${dataPath} should not have fewer than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "minProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty object${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
-
-          return `${dataPath} should not have fewer than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "maxLength":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          const max = limit + 1;
-          return `${dataPath} should be shorter than ${max} character${max > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "maxItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "maxProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "uniqueItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            i
-          } =
-          /** @type {import("ajv").UniqueItemsParams} */
-          params;
-          return `${dataPath} should not contain the item '${error.data[i]}' twice${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "additionalItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}. These items are valid:\n${this.getSchemaPartText(parentSchema)}`;
-        }
-
-      case "contains":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should contains at least one ${this.getSchemaPartText(parentSchema, ["contains"])} item${getSchemaNonTypes(parentSchema)}.`;
-        }
-
-      case "required":
-        {
-          const {
-            parentSchema,
-            params
-          } = error;
-          const missingProperty =
-          /** @type {import("ajv").DependenciesParams} */
-          params.missingProperty.replace(/^\./, "");
-          const hasProperty = parentSchema && Boolean(
-          /** @type {Schema} */
-          parentSchema.properties &&
-          /** @type {Schema} */
-          parentSchema.properties[missingProperty]);
-          return `${dataPath} misses the property '${missingProperty}'${getSchemaNonTypes(parentSchema)}.${hasProperty ? ` Should be:\n${this.getSchemaPartText(parentSchema, ["properties", missingProperty])}` : this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "additionalProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            additionalProperty
-          } =
-          /** @type {import("ajv").AdditionalPropertiesParams} */
-          params;
-          return `${dataPath} has an unknown property '${additionalProperty}'${getSchemaNonTypes(parentSchema)}. These properties are valid:\n${this.getSchemaPartText(parentSchema)}`;
-        }
-
-      case "dependencies":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            property,
-            deps
-          } =
-          /** @type {import("ajv").DependenciesParams} */
-          params;
-          const dependencies = deps.split(",").map(
-          /**
-           * @param {string} dep
-           * @returns {string}
-           */
-          dep => `'${dep.trim()}'`).join(", ");
-          return `${dataPath} should have properties ${dependencies} when property '${property}' is present${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "propertyNames":
-        {
-          const {
-            params,
-            parentSchema,
-            schema
-          } = error;
-          const {
-            propertyName
-          } =
-          /** @type {import("ajv").PropertyNamesParams} */
-          params;
-          return `${dataPath} property name '${propertyName}' is invalid${getSchemaNonTypes(parentSchema)}. Property names should be match format ${JSON.stringify(schema.format)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "enum":
-        {
-          const {
-            parentSchema
-          } = error;
-
-          if (parentSchema &&
-          /** @type {Schema} */
-          parentSchema.enum &&
-          /** @type {Schema} */
-          parentSchema.enum.length === 1) {
-            return `${dataPath} should be ${this.getSchemaPartText(parentSchema, false, true)}`;
-          }
-
-          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
-        }
-
-      case "const":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should be equal to constant ${this.getSchemaPartText(parentSchema, false, true)}`;
-        }
-
-      case "not":
-        {
-          const postfix = likeObject(
-          /** @type {Schema} */
-          error.parentSchema) ? `\n${this.getSchemaPartText(error.parentSchema)}` : "";
-          const schemaOutput = this.getSchemaPartText(error.schema, false, false, false);
-
-          if (canApplyNot(error.schema)) {
-            return `${dataPath} should be any ${schemaOutput}${postfix}.`;
-          }
-
-          const {
-            schema,
-            parentSchema
-          } = error;
-          return `${dataPath} should not be ${this.getSchemaPartText(schema, false, true)}${parentSchema && likeObject(parentSchema) ? `\n${this.getSchemaPartText(parentSchema)}` : ""}`;
-        }
-
-      case "oneOf":
-      case "anyOf":
-        {
-          const {
-            parentSchema,
-            children
-          } = error;
-
-          if (children && children.length > 0) {
-            if (error.schema.length === 1) {
-              const lastChild = children[children.length - 1];
-              const remainingChildren = children.slice(0, children.length - 1);
-              return this.formatValidationError(Object.assign({}, lastChild, {
-                children: remainingChildren,
-                parentSchema: Object.assign({}, parentSchema, lastChild.parentSchema)
-              }));
-            }
-
-            let filteredChildren = filterChildren(children);
-
-            if (filteredChildren.length === 1) {
-              return this.formatValidationError(filteredChildren[0]);
-            }
-
-            filteredChildren = groupChildrenByFirstChild(filteredChildren);
-            return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}\nDetails:\n${filteredChildren.map(
-            /**
-             * @param {SchemaUtilErrorObject} nestedError
-             * @returns {string}
-             */
-            nestedError => ` * ${indent(this.formatValidationError(nestedError), "   ")}`).join("\n")}`;
-          }
-
-          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
-        }
-
-      case "if":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            failingKeyword
-          } =
-          /** @type {import("ajv").IfParams} */
-          params;
-          return `${dataPath} should match "${failingKeyword}" schema:\n${this.getSchemaPartText(parentSchema, [failingKeyword])}`;
-        }
-
-      case "absolutePath":
-        {
-          const {
-            message,
-            parentSchema
-          } = error;
-          return `${dataPath}: ${message}${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      /* istanbul ignore next */
-
-      default:
-        {
-          const {
-            message,
-            parentSchema
-          } = error;
-          const ErrorInJSON = JSON.stringify(error, null, 2); // For `custom`, `false schema`, `$ref` keywords
-          // Fallback for unknown keywords
-
-          return `${dataPath} ${message} (${ErrorInJSON}).\n${this.getSchemaPartText(parentSchema, false)}`;
-        }
-    }
-  }
-  /**
-   * @param {Array<SchemaUtilErrorObject>} errors
-   * @returns {string}
-   */
-
-
-  formatValidationErrors(errors) {
-    return errors.map(error => {
-      let formattedError = this.formatValidationError(error);
-
-      if (this.postFormatter) {
-        formattedError = this.postFormatter(formattedError, error);
-      }
-
-      return ` - ${indent(formattedError, "   ")}`;
-    }).join("\n");
-  }
-
-}
-
-var _default = ValidationError;
-exports.default = _default;

admin/node_modules/sass-loader/node_modules/schema-utils/dist/index.js

@@ -1,11 +0,0 @@
-"use strict";
-
-const {
-  validate,
-  ValidationError
-} = require("./validate");
-
-module.exports = {
-  validate,
-  ValidationError
-};

admin/node_modules/sass-loader/node_modules/schema-utils/dist/keywords/absolutePath.js

@@ -1,93 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-/** @typedef {import("ajv").Ajv} Ajv */
-
-/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
-
-/** @typedef {import("../validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
-
-/**
- * @param {string} message
- * @param {object} schema
- * @param {string} data
- * @returns {SchemaUtilErrorObject}
- */
-function errorMessage(message, schema, data) {
-  return {
-    // @ts-ignore
-    // eslint-disable-next-line no-undefined
-    dataPath: undefined,
-    // @ts-ignore
-    // eslint-disable-next-line no-undefined
-    schemaPath: undefined,
-    keyword: "absolutePath",
-    params: {
-      absolutePath: data
-    },
-    message,
-    parentSchema: schema
-  };
-}
-/**
- * @param {boolean} shouldBeAbsolute
- * @param {object} schema
- * @param {string} data
- * @returns {SchemaUtilErrorObject}
- */
-
-
-function getErrorFor(shouldBeAbsolute, schema, data) {
-  const message = shouldBeAbsolute ? `The provided value ${JSON.stringify(data)} is not an absolute path!` : `A relative path is expected. However, the provided value ${JSON.stringify(data)} is an absolute path!`;
-  return errorMessage(message, schema, data);
-}
-/**
- *
- * @param {Ajv} ajv
- * @returns {Ajv}
- */
-
-
-function addAbsolutePathKeyword(ajv) {
-  ajv.addKeyword("absolutePath", {
-    errors: true,
-    type: "string",
-
-    compile(schema, parentSchema) {
-      /** @type {ValidateFunction} */
-      const callback = data => {
-        let passes = true;
-        const isExclamationMarkPresent = data.includes("!");
-
-        if (isExclamationMarkPresent) {
-          callback.errors = [errorMessage(`The provided value ${JSON.stringify(data)} contains exclamation mark (!) which is not allowed because it's reserved for loader syntax.`, parentSchema, data)];
-          passes = false;
-        } // ?:[A-Za-z]:\\ - Windows absolute path
-        // \\\\ - Windows network absolute path
-        // \/ - Unix-like OS absolute path
-
-
-        const isCorrectAbsolutePath = schema === /^(?:[A-Za-z]:(\\|\/)|\\\\|\/)/.test(data);
-
-        if (!isCorrectAbsolutePath) {
-          callback.errors = [getErrorFor(schema, parentSchema, data)];
-          passes = false;
-        }
-
-        return passes;
-      };
-
-      callback.errors = [];
-      return callback;
-    }
-
-  });
-  return ajv;
-}
-
-var _default = addAbsolutePathKeyword;
-exports.default = _default;

admin/node_modules/sass-loader/node_modules/schema-utils/dist/util/Range.js

@@ -1,163 +0,0 @@
-"use strict";
-
-/**
- * @typedef {[number, boolean]} RangeValue
- */
-
-/**
- * @callback RangeValueCallback
- * @param {RangeValue} rangeValue
- * @returns {boolean}
- */
-class Range {
-  /**
-   * @param {"left" | "right"} side
-   * @param {boolean} exclusive
-   * @returns {">" | ">=" | "<" | "<="}
-   */
-  static getOperator(side, exclusive) {
-    if (side === "left") {
-      return exclusive ? ">" : ">=";
-    }
-
-    return exclusive ? "<" : "<=";
-  }
-  /**
-   * @param {number} value
-   * @param {boolean} logic is not logic applied
-   * @param {boolean} exclusive is range exclusive
-   * @returns {string}
-   */
-
-
-  static formatRight(value, logic, exclusive) {
-    if (logic === false) {
-      return Range.formatLeft(value, !logic, !exclusive);
-    }
-
-    return `should be ${Range.getOperator("right", exclusive)} ${value}`;
-  }
-  /**
-   * @param {number} value
-   * @param {boolean} logic is not logic applied
-   * @param {boolean} exclusive is range exclusive
-   * @returns {string}
-   */
-
-
-  static formatLeft(value, logic, exclusive) {
-    if (logic === false) {
-      return Range.formatRight(value, !logic, !exclusive);
-    }
-
-    return `should be ${Range.getOperator("left", exclusive)} ${value}`;
-  }
-  /**
-   * @param {number} start left side value
-   * @param {number} end right side value
-   * @param {boolean} startExclusive is range exclusive from left side
-   * @param {boolean} endExclusive is range exclusive from right side
-   * @param {boolean} logic is not logic applied
-   * @returns {string}
-   */
-
-
-  static formatRange(start, end, startExclusive, endExclusive, logic) {
-    let result = "should be";
-    result += ` ${Range.getOperator(logic ? "left" : "right", logic ? startExclusive : !startExclusive)} ${start} `;
-    result += logic ? "and" : "or";
-    result += ` ${Range.getOperator(logic ? "right" : "left", logic ? endExclusive : !endExclusive)} ${end}`;
-    return result;
-  }
-  /**
-   * @param {Array<RangeValue>} values
-   * @param {boolean} logic is not logic applied
-   * @return {RangeValue} computed value and it's exclusive flag
-   */
-
-
-  static getRangeValue(values, logic) {
-    let minMax = logic ? Infinity : -Infinity;
-    let j = -1;
-    const predicate = logic ?
-    /** @type {RangeValueCallback} */
-    ([value]) => value <= minMax :
-    /** @type {RangeValueCallback} */
-    ([value]) => value >= minMax;
-
-    for (let i = 0; i < values.length; i++) {
-      if (predicate(values[i])) {
-        [minMax] = values[i];
-        j = i;
-      }
-    }
-
-    if (j > -1) {
-      return values[j];
-    }
-
-    return [Infinity, true];
-  }
-
-  constructor() {
-    /** @type {Array<RangeValue>} */
-    this._left = [];
-    /** @type {Array<RangeValue>} */
-
-    this._right = [];
-  }
-  /**
-   * @param {number} value
-   * @param {boolean=} exclusive
-   */
-
-
-  left(value, exclusive = false) {
-    this._left.push([value, exclusive]);
-  }
-  /**
-   * @param {number} value
-   * @param {boolean=} exclusive
-   */
-
-
-  right(value, exclusive = false) {
-    this._right.push([value, exclusive]);
-  }
-  /**
-   * @param {boolean} logic is not logic applied
-   * @return {string} "smart" range string representation
-   */
-
-
-  format(logic = true) {
-    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
-    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
-
-    if (!Number.isFinite(start) && !Number.isFinite(end)) {
-      return "";
-    }
-
-    const realStart = leftExclusive ? start + 1 : start;
-    const realEnd = rightExclusive ? end - 1 : end; // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
-
-    if (realStart === realEnd) {
-      return `should be ${logic ? "" : "!"}= ${realStart}`;
-    } // e.g. 4 < x < ∞
-
-
-    if (Number.isFinite(start) && !Number.isFinite(end)) {
-      return Range.formatLeft(start, logic, leftExclusive);
-    } // e.g. ∞ < x < 4
-
-
-    if (!Number.isFinite(start) && Number.isFinite(end)) {
-      return Range.formatRight(end, logic, rightExclusive);
-    }
-
-    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
-  }
-
-}
-
-module.exports = Range;

admin/node_modules/sass-loader/node_modules/schema-utils/dist/util/hints.js

@@ -1,105 +0,0 @@
-"use strict";
-
-const Range = require("./Range");
-/** @typedef {import("../validate").Schema} Schema */
-
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @return {string[]}
- */
-
-
-module.exports.stringHints = function stringHints(schema, logic) {
-  const hints = [];
-  let type = "string";
-  const currentSchema = { ...schema
-  };
-
-  if (!logic) {
-    const tmpLength = currentSchema.minLength;
-    const tmpFormat = currentSchema.formatMinimum;
-    const tmpExclusive = currentSchema.formatExclusiveMaximum;
-    currentSchema.minLength = currentSchema.maxLength;
-    currentSchema.maxLength = tmpLength;
-    currentSchema.formatMinimum = currentSchema.formatMaximum;
-    currentSchema.formatMaximum = tmpFormat;
-    currentSchema.formatExclusiveMaximum = !currentSchema.formatExclusiveMinimum;
-    currentSchema.formatExclusiveMinimum = !tmpExclusive;
-  }
-
-  if (typeof currentSchema.minLength === "number") {
-    if (currentSchema.minLength === 1) {
-      type = "non-empty string";
-    } else {
-      const length = Math.max(currentSchema.minLength - 1, 0);
-      hints.push(`should be longer than ${length} character${length > 1 ? "s" : ""}`);
-    }
-  }
-
-  if (typeof currentSchema.maxLength === "number") {
-    if (currentSchema.maxLength === 0) {
-      type = "empty string";
-    } else {
-      const length = currentSchema.maxLength + 1;
-      hints.push(`should be shorter than ${length} character${length > 1 ? "s" : ""}`);
-    }
-  }
-
-  if (currentSchema.pattern) {
-    hints.push(`should${logic ? "" : " not"} match pattern ${JSON.stringify(currentSchema.pattern)}`);
-  }
-
-  if (currentSchema.format) {
-    hints.push(`should${logic ? "" : " not"} match format ${JSON.stringify(currentSchema.format)}`);
-  }
-
-  if (currentSchema.formatMinimum) {
-    hints.push(`should be ${currentSchema.formatExclusiveMinimum ? ">" : ">="} ${JSON.stringify(currentSchema.formatMinimum)}`);
-  }
-
-  if (currentSchema.formatMaximum) {
-    hints.push(`should be ${currentSchema.formatExclusiveMaximum ? "<" : "<="} ${JSON.stringify(currentSchema.formatMaximum)}`);
-  }
-
-  return [type].concat(hints);
-};
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @return {string[]}
- */
-
-
-module.exports.numberHints = function numberHints(schema, logic) {
-  const hints = [schema.type === "integer" ? "integer" : "number"];
-  const range = new Range();
-
-  if (typeof schema.minimum === "number") {
-    range.left(schema.minimum);
-  }
-
-  if (typeof schema.exclusiveMinimum === "number") {
-    range.left(schema.exclusiveMinimum, true);
-  }
-
-  if (typeof schema.maximum === "number") {
-    range.right(schema.maximum);
-  }
-
-  if (typeof schema.exclusiveMaximum === "number") {
-    range.right(schema.exclusiveMaximum, true);
-  }
-
-  const rangeFormat = range.format(logic);
-
-  if (rangeFormat) {
-    hints.push(rangeFormat);
-  }
-
-  if (typeof schema.multipleOf === "number") {
-    hints.push(`should${logic ? "" : " not"} be multiple of ${schema.multipleOf}`);
-  }
-
-  return hints;
-};

admin/node_modules/sass-loader/node_modules/schema-utils/dist/validate.js

@@ -1,163 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validate = validate;
-Object.defineProperty(exports, "ValidationError", {
-  enumerable: true,
-  get: function () {
-    return _ValidationError.default;
-  }
-});
-
-var _absolutePath = _interopRequireDefault(require("./keywords/absolutePath"));
-
-var _ValidationError = _interopRequireDefault(require("./ValidationError"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// Use CommonJS require for ajv libs so TypeScript consumers aren't locked into esModuleInterop (see #110).
-const Ajv = require("ajv");
-
-const ajvKeywords = require("ajv-keywords");
-/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
-
-/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
-
-/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
-
-/** @typedef {import("ajv").ErrorObject} ErrorObject */
-
-/**
- * @typedef {Object} Extend
- * @property {number=} formatMinimum
- * @property {number=} formatMaximum
- * @property {boolean=} formatExclusiveMinimum
- * @property {boolean=} formatExclusiveMaximum
- * @property {string=} link
- */
-
-/** @typedef {(JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend} Schema */
-
-/** @typedef {ErrorObject & { children?: Array<ErrorObject>}} SchemaUtilErrorObject */
-
-/**
- * @callback PostFormatter
- * @param {string} formattedError
- * @param {SchemaUtilErrorObject} error
- * @returns {string}
- */
-
-/**
- * @typedef {Object} ValidationErrorConfiguration
- * @property {string=} name
- * @property {string=} baseDataPath
- * @property {PostFormatter=} postFormatter
- */
-
-
-const ajv = new Ajv({
-  allErrors: true,
-  verbose: true,
-  $data: true
-});
-ajvKeywords(ajv, ["instanceof", "formatMinimum", "formatMaximum", "patternRequired"]); // Custom keywords
-
-(0, _absolutePath.default)(ajv);
-/**
- * @param {Schema} schema
- * @param {Array<object> | object} options
- * @param {ValidationErrorConfiguration=} configuration
- * @returns {void}
- */
-
-function validate(schema, options, configuration) {
-  let errors = [];
-
-  if (Array.isArray(options)) {
-    errors = Array.from(options, nestedOptions => validateObject(schema, nestedOptions));
-    errors.forEach((list, idx) => {
-      const applyPrefix =
-      /**
-       * @param {SchemaUtilErrorObject} error
-       */
-      error => {
-        // eslint-disable-next-line no-param-reassign
-        error.dataPath = `[${idx}]${error.dataPath}`;
-
-        if (error.children) {
-          error.children.forEach(applyPrefix);
-        }
-      };
-
-      list.forEach(applyPrefix);
-    });
-    errors = errors.reduce((arr, items) => {
-      arr.push(...items);
-      return arr;
-    }, []);
-  } else {
-    errors = validateObject(schema, options);
-  }
-
-  if (errors.length > 0) {
-    throw new _ValidationError.default(errors, schema, configuration);
-  }
-}
-/**
- * @param {Schema} schema
- * @param {Array<object> | object} options
- * @returns {Array<SchemaUtilErrorObject>}
- */
-
-
-function validateObject(schema, options) {
-  const compiledSchema = ajv.compile(schema);
-  const valid = compiledSchema(options);
-  if (valid) return [];
-  return compiledSchema.errors ? filterErrors(compiledSchema.errors) : [];
-}
-/**
- * @param {Array<ErrorObject>} errors
- * @returns {Array<SchemaUtilErrorObject>}
- */
-
-
-function filterErrors(errors) {
-  /** @type {Array<SchemaUtilErrorObject>} */
-  let newErrors = [];
-
-  for (const error of
-  /** @type {Array<SchemaUtilErrorObject>} */
-  errors) {
-    const {
-      dataPath
-    } = error;
-    /** @type {Array<SchemaUtilErrorObject>} */
-
-    let children = [];
-    newErrors = newErrors.filter(oldError => {
-      if (oldError.dataPath.includes(dataPath)) {
-        if (oldError.children) {
-          children = children.concat(oldError.children.slice(0));
-        } // eslint-disable-next-line no-undefined, no-param-reassign
-
-
-        oldError.children = undefined;
-        children.push(oldError);
-        return false;
-      }
-
-      return true;
-    });
-
-    if (children.length) {
-      error.children = children;
-    }
-
-    newErrors.push(error);
-  }
-
-  return newErrors;
-}

admin/node_modules/sass-loader/node_modules/schema-utils/package.json

@@ -1,115 +0,0 @@
-{
-  "_args": [
-    [
-      "schema-utils@3.1.1",
-      "D:\\zhaogongxue\\crm\\template\\admin"
-    ]
-  ],
-  "_development": true,
-  "_from": "schema-utils@3.1.1",
-  "_id": "schema-utils@3.1.1",
-  "_inBundle": false,
-  "_integrity": "sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==",
-  "_location": "/sass-loader/schema-utils",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "schema-utils@3.1.1",
-    "name": "schema-utils",
-    "escapedName": "schema-utils",
-    "rawSpec": "3.1.1",
-    "saveSpec": null,
-    "fetchSpec": "3.1.1"
-  },
-  "_requiredBy": [
-    "/sass-loader"
-  ],
-  "_resolved": "https://registry.npmmirror.com/schema-utils/-/schema-utils-3.1.1.tgz",
-  "_spec": "3.1.1",
-  "_where": "D:\\zhaogongxue\\crm\\template\\admin",
-  "author": {
-    "name": "webpack Contrib",
-    "url": "https://github.com/webpack-contrib"
-  },
-  "bugs": {
-    "url": "https://github.com/webpack/schema-utils/issues"
-  },
-  "dependencies": {
-    "@types/json-schema": "^7.0.8",
-    "ajv": "^6.12.5",
-    "ajv-keywords": "^3.5.2"
-  },
-  "description": "webpack Validation Utils",
-  "devDependencies": {
-    "@babel/cli": "^7.14.3",
-    "@babel/core": "^7.14.6",
-    "@babel/preset-env": "^7.14.7",
-    "@commitlint/cli": "^12.1.4",
-    "@commitlint/config-conventional": "^12.1.4",
-    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
-    "babel-jest": "^27.0.6",
-    "cross-env": "^7.0.3",
-    "del": "^6.0.0",
-    "del-cli": "^3.0.1",
-    "eslint": "^7.31.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.23.4",
-    "husky": "^6.0.0",
-    "jest": "^27.0.6",
-    "lint-staged": "^11.0.1",
-    "npm-run-all": "^4.1.5",
-    "prettier": "^2.3.2",
-    "standard-version": "^9.3.1",
-    "typescript": "^4.3.5",
-    "webpack": "^5.45.1"
-  },
-  "engines": {
-    "node": ">= 10.13.0"
-  },
-  "files": [
-    "dist",
-    "declarations"
-  ],
-  "funding": {
-    "type": "opencollective",
-    "url": "https://opencollective.com/webpack"
-  },
-  "homepage": "https://github.com/webpack/schema-utils",
-  "keywords": [
-    "webpack"
-  ],
-  "license": "MIT",
-  "main": "dist/index.js",
-  "name": "schema-utils",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/webpack/schema-utils.git"
-  },
-  "scripts": {
-    "build": "npm-run-all -p \"build:**\"",
-    "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
-    "build:types": "tsc --declaration --emitDeclarationOnly --outDir declarations && prettier \"declarations/**/*.ts\" --write",
-    "clean": "del-cli dist declarations",
-    "commitlint": "commitlint --from=master",
-    "fix": "npm-run-all fix:js fmt",
-    "fix:js": "npm run lint:js -- --fix",
-    "fmt": "npm run fmt:check -- --write",
-    "fmt:check": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
-    "lint": "npm-run-all lint:js lint:types fmt:check",
-    "lint:js": "eslint --cache .",
-    "lint:types": "tsc --pretty --noEmit",
-    "prebuild": "npm run clean",
-    "prepare": "npm run build && husky install",
-    "pretest": "npm run lint",
-    "release": "standard-version",
-    "security": "npm audit --production",
-    "start": "npm run build -- -w",
-    "test": "npm run test:coverage",
-    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
-    "test:only": "cross-env NODE_ENV=test jest",
-    "test:watch": "npm run test:only -- --watch"
-  },
-  "types": "declarations/index.d.ts",
-  "version": "3.1.1"
-}

admin/node_modules/sass-loader/node_modules/semver/LICENSE

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

admin/node_modules/sass-loader/node_modules/semver/README.md

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

admin/node_modules/sass-loader/node_modules/semver/bin/semver.js

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

admin/node_modules/sass-loader/node_modules/semver/classes/comparator.js

@@ -1,136 +0,0 @@
-const ANY = Symbol('SemVer ANY')
-// hoisted class for cyclic dependency
-class Comparator {
-  static get ANY () {
-    return ANY
-  }
-
-  constructor (comp, options) {
-    options = parseOptions(options)
-
-    if (comp instanceof Comparator) {
-      if (comp.loose === !!options.loose) {
-        return comp
-      } else {
-        comp = comp.value
-      }
-    }
-
-    debug('comparator', comp, options)
-    this.options = options
-    this.loose = !!options.loose
-    this.parse(comp)
-
-    if (this.semver === ANY) {
-      this.value = ''
-    } else {
-      this.value = this.operator + this.semver.version
-    }
-
-    debug('comp', this)
-  }
-
-  parse (comp) {
-    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
-    const m = comp.match(r)
-
-    if (!m) {
-      throw new TypeError(`Invalid comparator: ${comp}`)
-    }
-
-    this.operator = m[1] !== undefined ? m[1] : ''
-    if (this.operator === '=') {
-      this.operator = ''
-    }
-
-    // if it literally is just '>' or '' then allow anything.
-    if (!m[2]) {
-      this.semver = ANY
-    } else {
-      this.semver = new SemVer(m[2], this.options.loose)
-    }
-  }
-
-  toString () {
-    return this.value
-  }
-
-  test (version) {
-    debug('Comparator.test', version, this.options.loose)
-
-    if (this.semver === ANY || version === ANY) {
-      return true
-    }
-
-    if (typeof version === 'string') {
-      try {
-        version = new SemVer(version, this.options)
-      } catch (er) {
-        return false
-      }
-    }
-
-    return cmp(version, this.operator, this.semver, this.options)
-  }
-
-  intersects (comp, options) {
-    if (!(comp instanceof Comparator)) {
-      throw new TypeError('a Comparator is required')
-    }
-
-    if (!options || typeof options !== 'object') {
-      options = {
-        loose: !!options,
-        includePrerelease: false,
-      }
-    }
-
-    if (this.operator === '') {
-      if (this.value === '') {
-        return true
-      }
-      return new Range(comp.value, options).test(this.value)
-    } else if (comp.operator === '') {
-      if (comp.value === '') {
-        return true
-      }
-      return new Range(this.value, options).test(comp.semver)
-    }
-
-    const sameDirectionIncreasing =
-      (this.operator === '>=' || this.operator === '>') &&
-      (comp.operator === '>=' || comp.operator === '>')
-    const sameDirectionDecreasing =
-      (this.operator === '<=' || this.operator === '<') &&
-      (comp.operator === '<=' || comp.operator === '<')
-    const sameSemVer = this.semver.version === comp.semver.version
-    const differentDirectionsInclusive =
-      (this.operator === '>=' || this.operator === '<=') &&
-      (comp.operator === '>=' || comp.operator === '<=')
-    const oppositeDirectionsLessThan =
-      cmp(this.semver, '<', comp.semver, options) &&
-      (this.operator === '>=' || this.operator === '>') &&
-        (comp.operator === '<=' || comp.operator === '<')
-    const oppositeDirectionsGreaterThan =
-      cmp(this.semver, '>', comp.semver, options) &&
-      (this.operator === '<=' || this.operator === '<') &&
-        (comp.operator === '>=' || comp.operator === '>')
-
-    return (
-      sameDirectionIncreasing ||
-      sameDirectionDecreasing ||
-      (sameSemVer && differentDirectionsInclusive) ||
-      oppositeDirectionsLessThan ||
-      oppositeDirectionsGreaterThan
-    )
-  }
-}
-
-module.exports = Comparator
-
-const parseOptions = require('../internal/parse-options')
-const { re, t } = require('../internal/re')
-const cmp = require('../functions/cmp')
-const debug = require('../internal/debug')
-const SemVer = require('./semver')
-const Range = require('./range')

admin/node_modules/sass-loader/node_modules/semver/classes/index.js

@@ -1,5 +0,0 @@
-module.exports = {
-  SemVer: require('./semver.js'),
-  Range: require('./range.js'),
-  Comparator: require('./comparator.js'),
-}

admin/node_modules/sass-loader/node_modules/semver/classes/range.js

@@ -1,522 +0,0 @@
-// hoisted class for cyclic dependency
-class Range {
-  constructor (range, options) {
-    options = parseOptions(options)
-
-    if (range instanceof Range) {
-      if (
-        range.loose === !!options.loose &&
-        range.includePrerelease === !!options.includePrerelease
-      ) {
-        return range
-      } else {
-        return new Range(range.raw, options)
-      }
-    }
-
-    if (range instanceof Comparator) {
-      // just put it in the set and return
-      this.raw = range.value
-      this.set = [[range]]
-      this.format()
-      return this
-    }
-
-    this.options = options
-    this.loose = !!options.loose
-    this.includePrerelease = !!options.includePrerelease
-
-    // First, split based on boolean or ||
-    this.raw = range
-    this.set = range
-      .split('||')
-      // map the range to a 2d array of comparators
-      .map(r => this.parseRange(r.trim()))
-      // throw out any comparator lists that are empty
-      // this generally means that it was not a valid range, which is allowed
-      // in loose mode, but will still throw if the WHOLE range is invalid.
-      .filter(c => c.length)
-
-    if (!this.set.length) {
-      throw new TypeError(`Invalid SemVer Range: ${range}`)
-    }
-
-    // if we have any that are not the null set, throw out null sets.
-    if (this.set.length > 1) {
-      // keep the first one, in case they're all null sets
-      const first = this.set[0]
-      this.set = this.set.filter(c => !isNullSet(c[0]))
-      if (this.set.length === 0) {
-        this.set = [first]
-      } else if (this.set.length > 1) {
-        // if we have any that are *, then the range is just *
-        for (const c of this.set) {
-          if (c.length === 1 && isAny(c[0])) {
-            this.set = [c]
-            break
-          }
-        }
-      }
-    }
-
-    this.format()
-  }
-
-  format () {
-    this.range = this.set
-      .map((comps) => {
-        return comps.join(' ').trim()
-      })
-      .join('||')
-      .trim()
-    return this.range
-  }
-
-  toString () {
-    return this.range
-  }
-
-  parseRange (range) {
-    range = range.trim()
-
-    // memoize range parsing for performance.
-    // this is a very hot path, and fully deterministic.
-    const memoOpts = Object.keys(this.options).join(',')
-    const memoKey = `parseRange:${memoOpts}:${range}`
-    const cached = cache.get(memoKey)
-    if (cached) {
-      return cached
-    }
-
-    const loose = this.options.loose
-    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
-    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
-    debug('hyphen replace', range)
-    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
-    debug('comparator trim', range)
-
-    // `~ 1.2.3` => `~1.2.3`
-    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
-
-    // `^ 1.2.3` => `^1.2.3`
-    range = range.replace(re[t.CARETTRIM], caretTrimReplace)
-
-    // normalize spaces
-    range = range.split(/\s+/).join(' ')
-
-    // At this point, the range is completely trimmed and
-    // ready to be split into comparators.
-
-    let rangeList = range
-      .split(' ')
-      .map(comp => parseComparator(comp, this.options))
-      .join(' ')
-      .split(/\s+/)
-      // >=0.0.0 is equivalent to *
-      .map(comp => replaceGTE0(comp, this.options))
-
-    if (loose) {
-      // in loose mode, throw out any that are not valid comparators
-      rangeList = rangeList.filter(comp => {
-        debug('loose invalid filter', comp, this.options)
-        return !!comp.match(re[t.COMPARATORLOOSE])
-      })
-    }
-    debug('range list', rangeList)
-
-    // if any comparators are the null set, then replace with JUST null set
-    // if more than one comparator, remove any * comparators
-    // also, don't include the same comparator more than once
-    const rangeMap = new Map()
-    const comparators = rangeList.map(comp => new Comparator(comp, this.options))
-    for (const comp of comparators) {
-      if (isNullSet(comp)) {
-        return [comp]
-      }
-      rangeMap.set(comp.value, comp)
-    }
-    if (rangeMap.size > 1 && rangeMap.has('')) {
-      rangeMap.delete('')
-    }
-
-    const result = [...rangeMap.values()]
-    cache.set(memoKey, result)
-    return result
-  }
-
-  intersects (range, options) {
-    if (!(range instanceof Range)) {
-      throw new TypeError('a Range is required')
-    }
-
-    return this.set.some((thisComparators) => {
-      return (
-        isSatisfiable(thisComparators, options) &&
-        range.set.some((rangeComparators) => {
-          return (
-            isSatisfiable(rangeComparators, options) &&
-            thisComparators.every((thisComparator) => {
-              return rangeComparators.every((rangeComparator) => {
-                return thisComparator.intersects(rangeComparator, options)
-              })
-            })
-          )
-        })
-      )
-    })
-  }
-
-  // if ANY of the sets match ALL of its comparators, then pass
-  test (version) {
-    if (!version) {
-      return false
-    }
-
-    if (typeof version === 'string') {
-      try {
-        version = new SemVer(version, this.options)
-      } catch (er) {
-        return false
-      }
-    }
-
-    for (let i = 0; i < this.set.length; i++) {
-      if (testSet(this.set[i], version, this.options)) {
-        return true
-      }
-    }
-    return false
-  }
-}
-module.exports = Range
-
-const LRU = require('lru-cache')
-const cache = new LRU({ max: 1000 })
-
-const parseOptions = require('../internal/parse-options')
-const Comparator = require('./comparator')
-const debug = require('../internal/debug')
-const SemVer = require('./semver')
-const {
-  re,
-  t,
-  comparatorTrimReplace,
-  tildeTrimReplace,
-  caretTrimReplace,
-} = require('../internal/re')
-
-const isNullSet = c => c.value === '<0.0.0-0'
-const isAny = c => c.value === ''
-
-// take a set of comparators and determine whether there
-// exists a version which can satisfy it
-const isSatisfiable = (comparators, options) => {
-  let result = true
-  const remainingComparators = comparators.slice()
-  let testComparator = remainingComparators.pop()
-
-  while (result && remainingComparators.length) {
-    result = remainingComparators.every((otherComparator) => {
-      return testComparator.intersects(otherComparator, options)
-    })
-
-    testComparator = remainingComparators.pop()
-  }
-
-  return result
-}
-
-// comprised of xranges, tildes, stars, and gtlt's at this point.
-// already replaced the hyphen ranges
-// turn into a set of JUST comparators.
-const parseComparator = (comp, options) => {
-  debug('comp', comp, options)
-  comp = replaceCarets(comp, options)
-  debug('caret', comp)
-  comp = replaceTildes(comp, options)
-  debug('tildes', comp)
-  comp = replaceXRanges(comp, options)
-  debug('xrange', comp)
-  comp = replaceStars(comp, options)
-  debug('stars', comp)
-  return comp
-}
-
-const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
-
-// ~, ~> --> * (any, kinda silly)
-// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
-// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
-// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
-// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
-// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
-// ~0.0.1 --> >=0.0.1 <0.1.0-0
-const replaceTildes = (comp, options) =>
-  comp.trim().split(/\s+/).map((c) => {
-    return replaceTilde(c, options)
-  }).join(' ')
-
-const replaceTilde = (comp, options) => {
-  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
-  return comp.replace(r, (_, M, m, p, pr) => {
-    debug('tilde', comp, _, M, m, p, pr)
-    let ret
-
-    if (isX(M)) {
-      ret = ''
-    } else if (isX(m)) {
-      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
-    } else if (isX(p)) {
-      // ~1.2 == >=1.2.0 <1.3.0-0
-      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
-    } else if (pr) {
-      debug('replaceTilde pr', pr)
-      ret = `>=${M}.${m}.${p}-${pr
-      } <${M}.${+m + 1}.0-0`
-    } else {
-      // ~1.2.3 == >=1.2.3 <1.3.0-0
-      ret = `>=${M}.${m}.${p
-      } <${M}.${+m + 1}.0-0`
-    }
-
-    debug('tilde return', ret)
-    return ret
-  })
-}
-
-// ^ --> * (any, kinda silly)
-// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
-// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
-// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
-// ^1.2.3 --> >=1.2.3 <2.0.0-0
-// ^1.2.0 --> >=1.2.0 <2.0.0-0
-// ^0.0.1 --> >=0.0.1 <0.0.2-0
-// ^0.1.0 --> >=0.1.0 <0.2.0-0
-const replaceCarets = (comp, options) =>
-  comp.trim().split(/\s+/).map((c) => {
-    return replaceCaret(c, options)
-  }).join(' ')
-
-const replaceCaret = (comp, options) => {
-  debug('caret', comp, options)
-  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
-  const z = options.includePrerelease ? '-0' : ''
-  return comp.replace(r, (_, M, m, p, pr) => {
-    debug('caret', comp, _, M, m, p, pr)
-    let ret
-
-    if (isX(M)) {
-      ret = ''
-    } else if (isX(m)) {
-      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
-    } else if (isX(p)) {
-      if (M === '0') {
-        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
-      } else {
-        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
-      }
-    } else if (pr) {
-      debug('replaceCaret pr', pr)
-      if (M === '0') {
-        if (m === '0') {
-          ret = `>=${M}.${m}.${p}-${pr
-          } <${M}.${m}.${+p + 1}-0`
-        } else {
-          ret = `>=${M}.${m}.${p}-${pr
-          } <${M}.${+m + 1}.0-0`
-        }
-      } else {
-        ret = `>=${M}.${m}.${p}-${pr
-        } <${+M + 1}.0.0-0`
-      }
-    } else {
-      debug('no pr')
-      if (M === '0') {
-        if (m === '0') {
-          ret = `>=${M}.${m}.${p
-          }${z} <${M}.${m}.${+p + 1}-0`
-        } else {
-          ret = `>=${M}.${m}.${p
-          }${z} <${M}.${+m + 1}.0-0`
-        }
-      } else {
-        ret = `>=${M}.${m}.${p
-        } <${+M + 1}.0.0-0`
-      }
-    }
-
-    debug('caret return', ret)
-    return ret
-  })
-}
-
-const replaceXRanges = (comp, options) => {
-  debug('replaceXRanges', comp, options)
-  return comp.split(/\s+/).map((c) => {
-    return replaceXRange(c, options)
-  }).join(' ')
-}
-
-const replaceXRange = (comp, options) => {
-  comp = comp.trim()
-  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
-  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
-    debug('xRange', comp, ret, gtlt, M, m, p, pr)
-    const xM = isX(M)
-    const xm = xM || isX(m)
-    const xp = xm || isX(p)
-    const anyX = xp
-
-    if (gtlt === '=' && anyX) {
-      gtlt = ''
-    }
-
-    // if we're including prereleases in the match, then we need
-    // to fix this to -0, the lowest possible prerelease value
-    pr = options.includePrerelease ? '-0' : ''
-
-    if (xM) {
-      if (gtlt === '>' || gtlt === '<') {
-        // nothing is allowed
-        ret = '<0.0.0-0'
-      } else {
-        // nothing is forbidden
-        ret = '*'
-      }
-    } else if (gtlt && anyX) {
-      // we know patch is an x, because we have any x at all.
-      // replace X with 0
-      if (xm) {
-        m = 0
-      }
-      p = 0
-
-      if (gtlt === '>') {
-        // >1 => >=2.0.0
-        // >1.2 => >=1.3.0
-        gtlt = '>='
-        if (xm) {
-          M = +M + 1
-          m = 0
-          p = 0
-        } else {
-          m = +m + 1
-          p = 0
-        }
-      } else if (gtlt === '<=') {
-        // <=0.7.x is actually <0.8.0, since any 0.7.x should
-        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
-        gtlt = '<'
-        if (xm) {
-          M = +M + 1
-        } else {
-          m = +m + 1
-        }
-      }
-
-      if (gtlt === '<') {
-        pr = '-0'
-      }
-
-      ret = `${gtlt + M}.${m}.${p}${pr}`
-    } else if (xm) {
-      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
-    } else if (xp) {
-      ret = `>=${M}.${m}.0${pr
-      } <${M}.${+m + 1}.0-0`
-    }
-
-    debug('xRange return', ret)
-
-    return ret
-  })
-}
-
-// Because * is AND-ed with everything else in the comparator,
-// and '' means "any version", just remove the *s entirely.
-const replaceStars = (comp, options) => {
-  debug('replaceStars', comp, options)
-  // Looseness is ignored here.  star is always as loose as it gets!
-  return comp.trim().replace(re[t.STAR], '')
-}
-
-const replaceGTE0 = (comp, options) => {
-  debug('replaceGTE0', comp, options)
-  return comp.trim()
-    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
-}
-
-// This function is passed to string.replace(re[t.HYPHENRANGE])
-// M, m, patch, prerelease, build
-// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
-// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
-// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
-const hyphenReplace = incPr => ($0,
-  from, fM, fm, fp, fpr, fb,
-  to, tM, tm, tp, tpr, tb) => {
-  if (isX(fM)) {
-    from = ''
-  } else if (isX(fm)) {
-    from = `>=${fM}.0.0${incPr ? '-0' : ''}`
-  } else if (isX(fp)) {
-    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`
-  } else if (fpr) {
-    from = `>=${from}`
-  } else {
-    from = `>=${from}${incPr ? '-0' : ''}`
-  }
-
-  if (isX(tM)) {
-    to = ''
-  } else if (isX(tm)) {
-    to = `<${+tM + 1}.0.0-0`
-  } else if (isX(tp)) {
-    to = `<${tM}.${+tm + 1}.0-0`
-  } else if (tpr) {
-    to = `<=${tM}.${tm}.${tp}-${tpr}`
-  } else if (incPr) {
-    to = `<${tM}.${tm}.${+tp + 1}-0`
-  } else {
-    to = `<=${to}`
-  }
-
-  return (`${from} ${to}`).trim()
-}
-
-const testSet = (set, version, options) => {
-  for (let i = 0; i < set.length; i++) {
-    if (!set[i].test(version)) {
-      return false
-    }
-  }
-
-  if (version.prerelease.length && !options.includePrerelease) {
-    // Find the set of versions that are allowed to have prereleases
-    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
-    // That should allow `1.2.3-pr.2` to pass.
-    // However, `1.2.4-alpha.notready` should NOT be allowed,
-    // even though it's within the range set by the comparators.
-    for (let i = 0; i < set.length; i++) {
-      debug(set[i].semver)
-      if (set[i].semver === Comparator.ANY) {
-        continue
-      }
-
-      if (set[i].semver.prerelease.length > 0) {
-        const allowed = set[i].semver
-        if (allowed.major === version.major &&
-            allowed.minor === version.minor &&
-            allowed.patch === version.patch) {
-          return true
-        }
-      }
-    }
-
-    // Version has a -pre, but it's not one of the ones we like.
-    return false
-  }
-
-  return true
-}