first

node_modules/less-loader/LICENSE

@@ -0,0 +1,20 @@
+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.

node_modules/less-loader/README.md

@@ -0,0 +1,639 @@
+<div align="center">
+  <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]
+[![tests][tests]][tests-url]
+[![cover][cover]][cover-url]
+[![discussion][discussion]][discussion-url]
+[![size][size]][size-url]
+
+# less-loader
+
+A Less loader for webpack. Compiles Less to CSS.
+
+## Getting Started
+
+To begin, you'll need to install `less` and `less-loader`:
+
+```console
+npm install less less-loader --save-dev
+```
+
+or
+
+```console
+yarn add -D less less-loader
+```
+
+or
+
+```console
+pnpm add -D less less-loader
+```
+
+Then add the loader to your `webpack` config. For example:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          // compiles Less to CSS
+          "style-loader",
+          "css-loader",
+          "less-loader",
+        ],
+      },
+    ],
+  },
+};
+```
+
+And run `webpack` via your preferred method.
+
+## Options
+
+- **[`lessOptions`](#lessoptions)**
+- **[`additionalData`](#additionalData)**
+- **[`sourceMap`](#sourcemap)**
+- **[`webpackImporter`](#webpackimporter)**
+- **[`implementation`](#implementation)**
+
+### `lessOptions`
+
+Type:
+
+```ts
+type lessOptions = import('less').options | ((loaderContext: LoaderContext) => import('less').options})
+```
+
+Default: `{ relativeUrls: true }`
+
+You can pass any Less specific options to the `less-loader` through the `lessOptions` property in the [loader options](https://webpack.js.org/configuration/module/#rule-options-rule-query). See the [Less documentation](http://lesscss.org/usage/#command-line-usage-options) for all available options in dash-case. Since we're passing these options to Less programmatically, you need to pass them in camelCase here:
+
+#### `object`
+
+Use an object to pass options through to Less.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          {
+            loader: "style-loader",
+          },
+          {
+            loader: "css-loader",
+          },
+          {
+            loader: "less-loader",
+            options: {
+              lessOptions: {
+                strictMath: true,
+              },
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+#### `function`
+
+Allows setting the options passed through to Less based off of the loader context.
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          "css-loader",
+          {
+            loader: "less-loader",
+            options: {
+              lessOptions: (loaderContext) => {
+                // More information about available properties https://webpack.js.org/api/loaders/
+                const { resourcePath, rootContext } = loaderContext;
+                const relativePath = path.relative(rootContext, resourcePath);
+
+                if (relativePath === "styles/foo.less") {
+                  return {
+                    paths: ["absolute/path/c", "absolute/path/d"],
+                  };
+                }
+
+                return {
+                  paths: ["absolute/path/a", "absolute/path/b"],
+                };
+              },
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+### `additionalData`
+
+Type:
+
+```ts
+type additionalData =
+  | string
+  | ((content: string, loaderContext: LoaderContext) => string);
+```
+
+Default: `undefined`
+
+Prepends/Appends `Less` code to the actual entry file.
+In this case, the `less-loader` will not override the source but just **prepend** the entry's content.
+
+This is especially useful when some of your Less variables depend on the environment:
+
+> Since you're injecting code, this will break the source mappings in your entry file. Often there's a simpler solution than this, like multiple Less entry files.
+
+#### `string`
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          "css-loader",
+          {
+            loader: "less-loader",
+            options: {
+              additionalData: `@env: ${process.env.NODE_ENV};`,
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+#### `function`
+
+##### `Sync`
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          "css-loader",
+          {
+            loader: "less-loader",
+            options: {
+              additionalData: (content, loaderContext) => {
+                // More information about available properties https://webpack.js.org/api/loaders/
+                const { resourcePath, rootContext } = loaderContext;
+                const relativePath = path.relative(rootContext, resourcePath);
+
+                if (relativePath === "styles/foo.less") {
+                  return "@value: 100px;" + content;
+                }
+
+                return "@value: 200px;" + content;
+              },
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+##### `Async`
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          "css-loader",
+          {
+            loader: "less-loader",
+            options: {
+              additionalData: async (content, loaderContext) => {
+                // More information about available properties https://webpack.js.org/api/loaders/
+                const { resourcePath, rootContext } = loaderContext;
+                const relativePath = path.relative(rootContext, resourcePath);
+
+                if (relativePath === "styles/foo.less") {
+                  return "@value: 100px;" + content;
+                }
+
+                return "@value: 200px;" + content;
+              },
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+### `sourceMap`
+
+Type:
+
+```ts
+type sourceMap = boolean;
+```
+
+Default: depends on the `compiler.devtool` value
+
+By default generation of source maps depends on the [`devtool`](https://webpack.js.org/configuration/devtool/) option. All values enable source map generation except `eval` and `false` value.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          {
+            loader: "css-loader",
+            options: {
+              sourceMap: true,
+            },
+          },
+          {
+            loader: "less-loader",
+            options: {
+              sourceMap: true,
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+### `webpackImporter`
+
+Type:
+
+```ts
+type webpackImporter = boolean;
+```
+
+Default: `true`
+
+Enables/Disables the default `webpack` importer.
+
+This can improve performance in some cases. Use it with caution because aliases and `@import` from [`node_modules`](https://webpack.js.org/configuration/resolve/#resolvemodules) will not work.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          "css-loader",
+          {
+            loader: "less-loader",
+            options: {
+              webpackImporter: false,
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+### `implementation`
+
+Type:
+
+```ts
+type implementation = object | string;
+```
+
+> less-loader compatible with Less 3 and 4 versions
+
+The special `implementation` option determines which implementation of Less to use. Overrides the locally installed `peerDependency` version of `less`.
+
+**This option is only really useful for downstream tooling authors to ease the Less 3-to-4 transition.**
+
+#### `object`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          "css-loader",
+          {
+            loader: "less-loader",
+            options: {
+              implementation: require("less"),
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+#### `string`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          "css-loader",
+          {
+            loader: "less-loader",
+            options: {
+              implementation: require.resolve("less"),
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+## Examples
+
+### Normal usage
+
+Chain the `less-loader` with the [`css-loader`](https://github.com/webpack-contrib/css-loader) and the [`style-loader`](https://github.com/webpack-contrib/style-loader) to immediately apply all styles to the DOM.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          {
+            loader: "style-loader", // creates style nodes from JS strings
+          },
+          {
+            loader: "css-loader", // translates CSS into CommonJS
+          },
+          {
+            loader: "less-loader", // compiles Less to CSS
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+Unfortunately, Less doesn't map all options 1-by-1 to camelCase. When in doubt, [check their executable](https://github.com/less/less.js/blob/3.x/bin/lessc) and search for the dash-case option.
+
+### Source maps
+
+To enable sourcemaps for CSS, you'll need to pass the `sourceMap` property in the loader's options. If this is not passed, the loader will respect the setting for webpack source maps, set in `devtool`.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  devtool: "source-map", // any "source-map"-like devtool is possible
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          "style-loader",
+          {
+            loader: "css-loader",
+            options: {
+              sourceMap: true,
+            },
+          },
+          {
+            loader: "less-loader",
+            options: {
+              sourceMap: true,
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+If you want to edit the original Less files inside Chrome, [there's a good blog post](https://medium.com/@toolmantim/getting-started-with-css-sourcemaps-and-in-browser-sass-editing-b4daab987fb0). The blog post is about Sass but it also works for Less.
+
+### In production
+
+Usually, it's recommended to extract the style sheets into a dedicated file in production using the [MiniCssExtractPlugin](https://github.com/webpack-contrib/mini-css-extract-plugin). This way your styles are not dependent on JavaScript.
+
+### Imports
+
+First we try to use built-in `less` resolve logic, then `webpack` resolve logic.
+
+#### Webpack Resolver
+
+`webpack` provides an [advanced mechanism to resolve files](https://webpack.js.org/configuration/resolve/).
+`less-loader` applies a Less plugin that passes all queries to the webpack resolver if `less` could not resolve `@import`.
+Thus you can import your Less modules from `node_modules`.
+
+```css
+@import "bootstrap/less/bootstrap";
+```
+
+Using `~` is deprecated and can be removed from your code (**we recommend it**), but we still support it for historical reasons.
+Why you can removed it? The loader will first try to resolve `@import` as relative, if it cannot be resolved, the loader will try to resolve `@import` inside [`node_modules`](https://webpack.js.org/configuration/resolve/#resolvemodules).
+
+Default resolver options can be modified by [`resolve.byDependency`](https://webpack.js.org/configuration/resolve/#resolvebydependency):
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  devtool: "source-map", // any "source-map"-like devtool is possible
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: ["style-loader", "css-loader", "less-loader"],
+      },
+    ],
+  },
+  resolve: {
+    byDependency: {
+      // More options can be found here https://webpack.js.org/configuration/resolve/
+      less: {
+        mainFiles: ["custom"],
+      },
+    },
+  },
+};
+```
+
+#### Less Resolver
+
+If you specify the `paths` option, modules will be searched in the given `paths`. This is `less` default behavior. `paths` should be an array with absolute paths:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.less$/i,
+        use: [
+          {
+            loader: "style-loader",
+          },
+          {
+            loader: "css-loader",
+          },
+          {
+            loader: "less-loader",
+            options: {
+              lessOptions: {
+                paths: [path.resolve(__dirname, "node_modules")],
+              },
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+### Plugins
+
+In order to use [plugins](http://lesscss.org/usage/#plugins), simply set the `plugins` option like this:
+
+**webpack.config.js**
+
+```js
+const CleanCSSPlugin = require('less-plugin-clean-css');
+
+module.exports = {
+  ...
+    {
+      loader: 'less-loader',
+      options: {
+        lessOptions: {
+          plugins: [
+            new CleanCSSPlugin({ advanced: true }),
+          ],
+        },
+      },
+    },
+  ...
+};
+```
+
+> **Note**
+>
+> Access to the [loader context](https://webpack.js.org/api/loaders/#the-loader-context) inside the custom plugin can be done using the `pluginManager.webpackLoaderContext` property.
+
+```js
+module.exports = {
+  install: function (less, pluginManager, functions) {
+    functions.add("pi", function () {
+      // Loader context is available in `pluginManager.webpackLoaderContext`
+
+      return Math.PI;
+    });
+  },
+};
+```
+
+### Extracting style sheets
+
+Bundling CSS with webpack has some nice advantages like referencing images and fonts with hashed urls or [hot module replacement](https://webpack.js.org/concepts/hot-module-replacement/) in development. In production, on the other hand, it's not a good idea to apply your style sheets depending on JS execution. Rendering may be delayed or even a [FOUC](https://en.wikipedia.org/wiki/Flash_of_unstyled_content) might be visible. Thus it's often still better to have them as separate files in your final production build.
+
+There are two possibilities to extract a style sheet from the bundle:
+
+- [`extract-loader`](https://github.com/peerigon/extract-loader) (simpler, but specialized on the css-loader's output)
+- [`MiniCssExtractPlugin`](https://github.com/webpack-contrib/mini-css-extract-plugin) (more complex, but works in all use-cases)
+
+### CSS modules gotcha
+
+There is a known problem with Less and [CSS modules](https://github.com/css-modules/css-modules) regarding relative file paths in `url(...)` statements. [See this issue for an explanation](https://github.com/webpack-contrib/less-loader/issues/109#issuecomment-253797335).
+
+## 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/less-loader.svg
+[npm-url]: https://npmjs.com/package/less-loader
+[node]: https://img.shields.io/node/v/less-loader.svg
+[node-url]: https://nodejs.org
+[tests]: https://github.com/webpack-contrib/less-loader/workflows/less-loader/badge.svg
+[tests-url]: https://github.com/webpack-contrib/less-loader/actions
+[cover]: https://codecov.io/gh/webpack-contrib/less-loader/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/less-loader
+[discussion]: https://img.shields.io/github/discussions/webpack/webpack
+[discussion-url]: https://github.com/webpack/webpack/discussions
+[size]: https://packagephobia.now.sh/badge?p=less-loader
+[size-url]: https://packagephobia.now.sh/result?p=less-loader

node_modules/less-loader/dist/cjs.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./index").default;

node_modules/less-loader/dist/index.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _options = _interopRequireDefault(require("./options.json"));
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+async function lessLoader(source) {
+  const options = this.getOptions(_options.default);
+  const callback = this.async();
+  let implementation;
+  try {
+    implementation = (0, _utils.getLessImplementation)(this, options.implementation);
+  } catch (error) {
+    callback(error);
+    return;
+  }
+  if (!implementation) {
+    callback(new Error(`The Less implementation "${options.implementation}" not found`));
+    return;
+  }
+  const lessOptions = (0, _utils.getLessOptions)(this, options, implementation);
+  const useSourceMap = typeof options.sourceMap === "boolean" ? options.sourceMap : this.sourceMap;
+  if (useSourceMap) {
+    lessOptions.sourceMap = {
+      outputSourceFiles: true
+    };
+  }
+  let data = source;
+  if (typeof options.additionalData !== "undefined") {
+    data = typeof options.additionalData === "function" ? `${await options.additionalData(data, this)}` : `${options.additionalData}\n${data}`;
+  }
+  const logger = this.getLogger("less-loader");
+  const loggerListener = {
+    error(message) {
+      logger.error(message);
+    },
+    warn(message) {
+      logger.warn(message);
+    },
+    info(message) {
+      logger.log(message);
+    },
+    debug(message) {
+      logger.debug(message);
+    }
+  };
+  implementation.logger.addListener(loggerListener);
+  let result;
+  try {
+    result = await implementation.render(data, lessOptions);
+  } catch (error) {
+    if (error.filename) {
+      // `less` returns forward slashes on windows when `webpack` resolver return an absolute windows path in `WebpackFileManager`
+      // Ref: https://github.com/webpack-contrib/less-loader/issues/357
+      this.addDependency(_path.default.normalize(error.filename));
+    }
+    callback((0, _utils.errorFactory)(error));
+    return;
+  } finally {
+    // Fix memory leaks in `less`
+    implementation.logger.removeListener(loggerListener);
+    delete lessOptions.pluginManager.webpackLoaderContext;
+    delete lessOptions.pluginManager;
+  }
+  const {
+    css,
+    imports
+  } = result;
+  imports.forEach(item => {
+    if ((0, _utils.isUnsupportedUrl)(item)) {
+      return;
+    }
+
+    // `less` return forward slashes on windows when `webpack` resolver return an absolute windows path in `WebpackFileManager`
+    // Ref: https://github.com/webpack-contrib/less-loader/issues/357
+    const normalizedItem = _path.default.normalize(item);
+
+    // Custom `importer` can return only `contents` so item will be relative
+    if (_path.default.isAbsolute(normalizedItem)) {
+      this.addDependency(normalizedItem);
+    }
+  });
+  let map = typeof result.map === "string" ? JSON.parse(result.map) : result.map;
+  if (map && useSourceMap) {
+    map = (0, _utils.normalizeSourceMap)(map, this.rootContext);
+  }
+  callback(null, css, map);
+}
+var _default = lessLoader;
+exports.default = _default;

node_modules/less-loader/dist/options.json

@@ -0,0 +1,54 @@
+{
+  "title": "Less Loader options",
+  "type": "object",
+  "properties": {
+    "lessOptions": {
+      "description": "Options to pass through to `Less`.",
+      "link": "https://github.com/webpack-contrib/less-loader#lessoptions",
+      "anyOf": [
+        {
+          "type": "object",
+          "additionalProperties": true
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "additionalData": {
+      "description": "Prepends/Appends `Less` code to the actual entry file.",
+      "link": "https://github.com/webpack-contrib/less-loader#additionalData",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "sourceMap": {
+      "description": "Enables/Disables generation of source maps.",
+      "link": "https://github.com/webpack-contrib/less-loader#sourcemap",
+      "type": "boolean"
+    },
+    "webpackImporter": {
+      "description": "Enables/Disables default `webpack` importer.",
+      "link": "https://github.com/webpack-contrib/less-loader#webpackimporter",
+      "type": "boolean"
+    },
+    "implementation": {
+      "description": "The implementation of the `Less` to be used.",
+      "link": "https://github.com/webpack-contrib/less-loader#implementation",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "object"
+        }
+      ]
+    }
+  },
+  "additionalProperties": false
+}

node_modules/less-loader/dist/utils.js

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errorFactory = errorFactory;
+exports.getLessImplementation = getLessImplementation;
+exports.getLessOptions = getLessOptions;
+exports.isUnsupportedUrl = isUnsupportedUrl;
+exports.normalizeSourceMap = normalizeSourceMap;
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable class-methods-use-this */
+const trailingSlash = /[/\\]$/;
+
+// This somewhat changed in Less 3.x. Now the file name comes without the
+// automatically added extension whereas the extension is passed in as `options.ext`.
+// So, if the file name matches this regexp, we simply ignore the proposed extension.
+const IS_SPECIAL_MODULE_IMPORT = /^~[^/]+$/;
+
+// `[drive_letter]:\` + `\\[server]\[share_name]\`
+const IS_NATIVE_WIN32_PATH = /^[a-z]:[/\\]|^\\\\/i;
+
+// Examples:
+// - ~package
+// - ~package/
+// - ~@org
+// - ~@org/
+// - ~@org/package
+// - ~@org/package/
+const IS_MODULE_IMPORT = /^~([^/]+|[^/]+\/|@[^/]+[/][^/]+|@[^/]+\/?|@[^/]+[/][^/]+\/)$/;
+const MODULE_REQUEST_REGEX = /^[^?]*~/;
+
+/**
+ * Creates a Less plugin that uses webpack's resolving engine that is provided by the loaderContext.
+ *
+ * @param {LoaderContext} loaderContext
+ * @param {object} implementation
+ * @returns {LessPlugin}
+ */
+function createWebpackLessPlugin(loaderContext, implementation) {
+  const resolve = loaderContext.getResolve({
+    dependencyType: "less",
+    conditionNames: ["less", "style", "..."],
+    mainFields: ["less", "style", "main", "..."],
+    mainFiles: ["index", "..."],
+    extensions: [".less", ".css"],
+    preferRelative: true
+  });
+  class WebpackFileManager extends implementation.FileManager {
+    supports(filename) {
+      if (filename[0] === "/" || IS_NATIVE_WIN32_PATH.test(filename)) {
+        return true;
+      }
+      if (this.isPathAbsolute(filename)) {
+        return false;
+      }
+      return true;
+    }
+
+    // Sync resolving is used at least by the `data-uri` function.
+    // This file manager doesn't know how to do it, so let's delegate it
+    // to the default file manager of Less.
+    // We could probably use loaderContext.resolveSync, but it's deprecated,
+    // see https://webpack.js.org/api/loaders/#this-resolvesync
+    supportsSync() {
+      return false;
+    }
+    async resolveFilename(filename, currentDirectory) {
+      // Less is giving us trailing slashes, but the context should have no trailing slash
+      const context = currentDirectory.replace(trailingSlash, "");
+      let request = filename;
+
+      // A `~` makes the url an module
+      if (MODULE_REQUEST_REGEX.test(filename)) {
+        request = request.replace(MODULE_REQUEST_REGEX, "");
+      }
+      if (IS_MODULE_IMPORT.test(filename)) {
+        request = request[request.length - 1] === "/" ? request : `${request}/`;
+      }
+      return this.resolveRequests(context, [...new Set([request, filename])]);
+    }
+    async resolveRequests(context, possibleRequests) {
+      if (possibleRequests.length === 0) {
+        return Promise.reject();
+      }
+      let result;
+      try {
+        result = await resolve(context, possibleRequests[0]);
+      } catch (error) {
+        const [, ...tailPossibleRequests] = possibleRequests;
+        if (tailPossibleRequests.length === 0) {
+          throw error;
+        }
+        result = await this.resolveRequests(context, tailPossibleRequests);
+      }
+      return result;
+    }
+    async loadFile(filename, ...args) {
+      let result;
+      try {
+        if (IS_SPECIAL_MODULE_IMPORT.test(filename)) {
+          const error = new Error();
+          error.type = "Next";
+          throw error;
+        }
+        result = await super.loadFile(filename, ...args);
+      } catch (error) {
+        if (error.type !== "File" && error.type !== "Next") {
+          return Promise.reject(error);
+        }
+        try {
+          result = await this.resolveFilename(filename, ...args);
+        } catch (webpackResolveError) {
+          error.message = `Less resolver error:\n${error.message}\n\n` + `Webpack resolver error details:\n${webpackResolveError.details}\n\n` + `Webpack resolver error missing:\n${webpackResolveError.missing}\n\n`;
+          return Promise.reject(error);
+        }
+        loaderContext.addDependency(result);
+        return super.loadFile(result, ...args);
+      }
+      loaderContext.addDependency(_path.default.normalize(result.filename));
+      return result;
+    }
+  }
+  return {
+    install(lessInstance, pluginManager) {
+      pluginManager.addFileManager(new WebpackFileManager());
+    },
+    minVersion: [3, 0, 0]
+  };
+}
+
+/**
+ * Get the `less` options from the loader context and normalizes its values
+ *
+ * @param {object} loaderContext
+ * @param {object} loaderOptions
+ * @param {object} implementation
+ * @returns {Object}
+ */
+function getLessOptions(loaderContext, loaderOptions, implementation) {
+  const options = typeof loaderOptions.lessOptions === "function" ? loaderOptions.lessOptions(loaderContext) || {} : loaderOptions.lessOptions || {};
+  const lessOptions = {
+    plugins: [],
+    relativeUrls: true,
+    // We need to set the filename because otherwise our WebpackFileManager will receive an undefined path for the entry
+    filename: loaderContext.resourcePath,
+    ...options
+  };
+  const plugins = lessOptions.plugins.slice();
+  const shouldUseWebpackImporter = typeof loaderOptions.webpackImporter === "boolean" ? loaderOptions.webpackImporter : true;
+  if (shouldUseWebpackImporter) {
+    plugins.unshift(createWebpackLessPlugin(loaderContext, implementation));
+  }
+  plugins.unshift({
+    install(lessProcessor, pluginManager) {
+      // eslint-disable-next-line no-param-reassign
+      pluginManager.webpackLoaderContext = loaderContext;
+      lessOptions.pluginManager = pluginManager;
+    }
+  });
+  lessOptions.plugins = plugins;
+  return lessOptions;
+}
+function isUnsupportedUrl(url) {
+  // Is Windows path
+  if (IS_NATIVE_WIN32_PATH.test(url)) {
+    return false;
+  }
+
+  // Scheme: https://tools.ietf.org/html/rfc3986#section-3.1
+  // Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url);
+}
+function normalizeSourceMap(map) {
+  const newMap = map;
+
+  // map.file is an optional property that provides the output filename.
+  // Since we don't know the final filename in the webpack build chain yet, it makes no sense to have it.
+  // eslint-disable-next-line no-param-reassign
+  delete newMap.file;
+
+  // eslint-disable-next-line no-param-reassign
+  newMap.sourceRoot = "";
+
+  // `less` returns POSIX paths, that's why we need to transform them back to native paths.
+  // eslint-disable-next-line no-param-reassign
+  newMap.sources = newMap.sources.map(source => _path.default.normalize(source));
+  return newMap;
+}
+function getLessImplementation(loaderContext, implementation) {
+  let resolvedImplementation = implementation;
+  if (!implementation || typeof implementation === "string") {
+    const lessImplPkg = implementation || "less";
+
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    resolvedImplementation = require(lessImplPkg);
+  }
+
+  // eslint-disable-next-line consistent-return
+  return resolvedImplementation;
+}
+function getFileExcerptIfPossible(error) {
+  if (typeof error.extract === "undefined") {
+    return [];
+  }
+  const excerpt = error.extract.slice(0, 2);
+  const column = Math.max(error.column - 1, 0);
+  if (typeof excerpt[0] === "undefined") {
+    excerpt.shift();
+  }
+  excerpt.push(`${new Array(column).join(" ")}^`);
+  return excerpt;
+}
+function errorFactory(error) {
+  const message = ["\n", ...getFileExcerptIfPossible(error), error.message.charAt(0).toUpperCase() + error.message.slice(1), error.filename ? `      Error in ${_path.default.normalize(error.filename)} (line ${error.line}, column ${error.column})` : ""].join("\n");
+  const obj = new Error(message, {
+    cause: error
+  });
+  obj.stack = null;
+  return obj;
+}

node_modules/less-loader/node_modules/.bin/lessc

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../../../less/bin/lessc" "$@"
+  ret=$?
+else 
+  node  "$basedir/../../../less/bin/lessc" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/less-loader/node_modules/.bin/lessc.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\..\..\less\bin\lessc" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\..\..\less\bin\lessc" %*
+)

node_modules/less-loader/package.json

@@ -0,0 +1,115 @@
+{
+  "_from": "less-loader@11.1.3",
+  "_id": "less-loader@11.1.3",
+  "_inBundle": false,
+  "_integrity": "sha512-A5b7O8dH9xpxvkosNrP0dFp2i/dISOJa9WwGF3WJflfqIERE2ybxh1BFDj5CovC2+jCE4M354mk90hN6ziXlVw==",
+  "_location": "/less-loader",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "less-loader@11.1.3",
+    "name": "less-loader",
+    "escapedName": "less-loader",
+    "rawSpec": "11.1.3",
+    "saveSpec": null,
+    "fetchSpec": "11.1.3"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/less-loader/-/less-loader-11.1.3.tgz",
+  "_shasum": "1bb62d6ca9bf00a177c02793b54baac40f9be694",
+  "_spec": "less-loader@11.1.3",
+  "_where": "C:\\Users\\zhouxueli\\Desktop\\scheduling-app",
+  "author": {
+    "name": "Johannes Ewald @jhnns"
+  },
+  "bugs": {
+    "url": "https://github.com/webpack-contrib/less-loader/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A Less loader for webpack. Compiles Less to CSS.",
+  "devDependencies": {
+    "@babel/cli": "^7.21.5",
+    "@babel/core": "^7.22.1",
+    "@babel/preset-env": "^7.22.4",
+    "@commitlint/cli": "^17.6.5",
+    "@commitlint/config-conventional": "^17.6.5",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^29.5.0",
+    "cross-env": "^7.0.3",
+    "cspell": "^6.31.1",
+    "del": "^6.1.1",
+    "del-cli": "^4.0.1",
+    "eslint": "^8.41.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "husky": "^8.0.3",
+    "jest": "^29.5.0",
+    "less": "^4.1.3",
+    "less-plugin-glob": "^2.0.2",
+    "lint-staged": "^13.2.2",
+    "memfs": "^3.5.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.8.8",
+    "standard-version": "^9.3.1",
+    "strip-ansi": "^7.1.0",
+    "webpack": "^5.85.0"
+  },
+  "engines": {
+    "node": ">= 14.15.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "homepage": "https://github.com/webpack-contrib/less-loader",
+  "keywords": [
+    "webpack",
+    "loader",
+    "less",
+    "lesscss",
+    "less.js",
+    "css",
+    "preprocessor"
+  ],
+  "license": "MIT",
+  "main": "dist/cjs.js",
+  "name": "less-loader",
+  "peerDependencies": {
+    "less": "^3.5.0 || ^4.0.0",
+    "webpack": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webpack-contrib/less-loader.git"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "clean": "del-cli dist",
+    "commitlint": "commitlint --from=master",
+    "fix": "npm-run-all -l fix:js fix:prettier",
+    "fix:js": "npm run lint:js -- --fix",
+    "fix:prettier": "npm run lint:prettier -- --write",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "lint:js": "eslint --cache .",
+    "lint:prettier": "prettier --list-different .",
+    "lint:spelling": "cspell \"**/*.*\"",
+    "prebuild": "npm run clean",
+    "prepare": "husky install && npm run build",
+    "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"
+  },
+  "version": "11.1.3"
+}