Index: frontend/node_modules/css-loader/LICENSE
===================================================================
--- frontend/node_modules/css-loader/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -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.
Index: frontend/node_modules/css-loader/README.md
===================================================================
--- frontend/node_modules/css-loader/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,2066 @@
+
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![discussion][discussion]][discussion-url]
+[![size][size]][size-url]
+
+# css-loader
+
+The `css-loader` interprets `@import` and `url()` like `import/require()` and will resolve them.
+
+## Getting Started
+
+> **Warning**
+>
+> To use the latest version of css-loader, webpack@5 is required
+
+To begin, you'll need to install `css-loader`:
+
+```console
+npm install --save-dev css-loader
+```
+
+or
+
+```console
+yarn add -D css-loader
+```
+
+or
+
+```console
+pnpm add -D css-loader
+```
+
+Then add the plugin to your `webpack` config. For example:
+
+**file.js**
+
+```js
+import css from "file.css";
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ use: ["style-loader", "css-loader"],
+ },
+ ],
+ },
+};
+```
+
+And run `webpack` via your preferred method.
+
+If, for one reason or another, you need to extract CSS as a file (i.e. do not store CSS in a JS module) you might want to check out the [recommend example](https://github.com/webpack-contrib/css-loader#recommend).
+
+## Options
+
+- **[`url`](#url)**
+- **[`import`](#import)**
+- **[`modules`](#modules)**
+- **[`sourceMap`](#sourcemap)**
+- **[`importLoaders`](#importloaders)**
+- **[`esModule`](#esmodule)**
+- **[`exportType`](#exporttype)**
+
+### `url`
+
+Type:
+
+```ts
+type url =
+ | boolean
+ | {
+ filter: (url: string, resourcePath: string) => boolean;
+ };
+```
+
+Default: `true`
+
+Allow to enable/disables handling the CSS functions `url` and `image-set`.
+If set to `false`, `css-loader` will not parse any paths specified in `url` or `image-set`.
+A function can also be passed to control this behavior dynamically based on the path to the asset.
+Starting with version [4.0.0](https://github.com/webpack-contrib/css-loader/blob/master/CHANGELOG.md#400-2020-07-25), absolute paths are parsed based on the server root.
+
+Examples resolutions:
+
+```js
+url(image.png) => require('./image.png')
+url('image.png') => require('./image.png')
+url(./image.png) => require('./image.png')
+url('./image.png') => require('./image.png')
+url('http://dontwritehorriblecode.com/2112.png') => require('http://dontwritehorriblecode.com/2112.png')
+image-set(url('image2x.png') 1x, url('image1x.png') 2x) => require('./image1x.png') and require('./image2x.png')
+```
+
+To import assets from a `node_modules` path (include `resolve.modules`) and for `alias`, prefix it with a `~`:
+
+```js
+url(~module/image.png) => require('module/image.png')
+url('~module/image.png') => require('module/image.png')
+url(~aliasDirectory/image.png) => require('otherDirectory/image.png')
+```
+
+#### `boolean`
+
+Enable/disable `url()` resolving.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ url: true,
+ },
+ },
+ ],
+ },
+};
+```
+
+#### `object`
+
+Allow to filter `url()`. All filtered `url()` will not be resolved (left in the code as they were written).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ url: {
+ filter: (url, resourcePath) => {
+ // resourcePath - path to css file
+
+ // Don't handle `img.png` urls
+ if (url.includes("img.png")) {
+ return false;
+ }
+
+ // Don't handle images under root-relative /external_images/
+ if (/^\/external_images\//.test(path)) {
+ return false;
+ }
+
+ return true;
+ },
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+### `import`
+
+Type:
+
+
+
+```ts
+type importFn =
+ | boolean
+ | {
+ filter: (
+ url: string,
+ media: string,
+ resourcePath: string,
+ supports?: string,
+ layer?: string
+ ) => boolean;
+ };
+```
+
+Default: `true`
+
+Allows to enables/disables `@import` at-rules handling.
+Control `@import` resolving. Absolute urls in `@import` will be moved in runtime code.
+
+Examples resolutions:
+
+```
+@import 'style.css' => require('./style.css')
+@import url(style.css) => require('./style.css')
+@import url('style.css') => require('./style.css')
+@import './style.css' => require('./style.css')
+@import url(./style.css) => require('./style.css')
+@import url('./style.css') => require('./style.css')
+@import url('http://dontwritehorriblecode.com/style.css') => @import url('http://dontwritehorriblecode.com/style.css') in runtime
+```
+
+To import styles from a `node_modules` path (include `resolve.modules`) and for `alias`, prefix it with a `~`:
+
+```
+@import url(~module/style.css) => require('module/style.css')
+@import url('~module/style.css') => require('module/style.css')
+@import url(~aliasDirectory/style.css) => require('otherDirectory/style.css')
+```
+
+#### `boolean`
+
+Enable/disable `@import` resolving.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ import: true,
+ },
+ },
+ ],
+ },
+};
+```
+
+#### `object`
+
+##### `filter`
+
+Type:
+
+```ts
+type filter = (url: string, media: string, resourcePath: string) => boolean;
+```
+
+Default: `undefined`
+
+Allow to filter `@import`. All filtered `@import` will not be resolved (left in the code as they were written).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ import: {
+ filter: (url, media, resourcePath) => {
+ // resourcePath - path to css file
+
+ // Don't handle `style.css` import
+ if (url.includes("style.css")) {
+ return false;
+ }
+
+ return true;
+ },
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+### `modules`
+
+Type:
+
+```ts
+type modules =
+ | boolean
+ | "local"
+ | "global"
+ | "pure"
+ | "icss"
+ | {
+ auto: boolean | regExp | ((resourcePath: string) => boolean);
+ mode:
+ | "local"
+ | "global"
+ | "pure"
+ | "icss"
+ | ((resourcePath) => "local" | "global" | "pure" | "icss");
+ localIdentName: string;
+ localIdentContext: string;
+ localIdentHashSalt: string;
+ localIdentHashFunction: string;
+ localIdentHashDigest: string;
+ localIdentRegExp: string | regExp;
+ getLocalIdent: (
+ context: LoaderContext,
+ localIdentName: string,
+ localName: string
+ ) => string;
+ namedExport: boolean;
+ exportGlobals: boolean;
+ exportLocalsConvention:
+ | "asIs"
+ | "camelCase"
+ | "camelCaseOnly"
+ | "dashes"
+ | "dashesOnly"
+ | ((name: string) => string);
+ exportOnlyLocals: boolean;
+ };
+```
+
+Default: `undefined`
+
+Allows to enable/disable CSS Modules or ICSS and setup configuration:
+
+- `undefined` - enable CSS modules for all files matching `/\.module\.\w+$/i.test(filename)` and `/\.icss\.\w+$/i.test(filename)` regexp.
+- `true` - enable CSS modules for all files.
+- `false` - disables CSS Modules for all files.
+- `string` - disables CSS Modules for all files and set the `mode` option, more information you can read [here](https://github.com/webpack-contrib/css-loader#mode)
+- `object` - enable CSS modules for all files, if `modules.auto` option is not specified, otherwise the `modules.auto` option will determine whether if it is CSS modules or not, more information you can read [here](https://github.com/webpack-contrib/css-loader#auto)
+
+The `modules` option enables/disables the **[CSS Modules](https://github.com/css-modules/css-modules)** specification and setup basic behaviour.
+
+Using `false` value increase performance because we avoid parsing **CSS Modules** features, it will be useful for developers who use vanilla css or use other technologies.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: true,
+ },
+ },
+ ],
+ },
+};
+```
+
+#### `Features`
+
+##### `Scope`
+
+Using `local` value requires you to specify `:global` classes.
+Using `global` value requires you to specify `:local` classes.
+Using `pure` value requires selectors must contain at least one local class or id.
+
+You can find more information [here](https://github.com/css-modules/css-modules).
+
+Styles can be locally scoped to avoid globally scoping styles.
+
+The syntax `:local(.className)` can be used to declare `className` in the local scope. The local identifiers are exported by the module.
+
+With `:local` (without brackets) local mode can be switched on for this selector.
+The `:global(.className)` notation can be used to declare an explicit global selector.
+With `:global` (without brackets) global mode can be switched on for this selector.
+
+The loader replaces local selectors with unique identifiers. The chosen unique identifiers are exported by the module.
+
+```css
+:local(.className) {
+ background: red;
+}
+:local .className {
+ color: green;
+}
+:local(.className .subClass) {
+ color: green;
+}
+:local .className .subClass :global(.global-class-name) {
+ color: blue;
+}
+```
+
+```css
+._23_aKvs-b8bW2Vg3fwHozO {
+ background: red;
+}
+._23_aKvs-b8bW2Vg3fwHozO {
+ color: green;
+}
+._23_aKvs-b8bW2Vg3fwHozO ._13LGdX8RMStbBE9w-t0gZ1 {
+ color: green;
+}
+._23_aKvs-b8bW2Vg3fwHozO ._13LGdX8RMStbBE9w-t0gZ1 .global-class-name {
+ color: blue;
+}
+```
+
+> **Note**
+>
+> Identifiers are exported
+
+```js
+exports.locals = {
+ className: "_23_aKvs-b8bW2Vg3fwHozO",
+ subClass: "_13LGdX8RMStbBE9w-t0gZ1",
+};
+```
+
+CamelCase is recommended for local selectors. They are easier to use within the imported JS module.
+
+You can use `:local(#someId)`, but this is not recommended. Use classes instead of ids.
+
+##### `Composing`
+
+When declaring a local classname you can compose a local class from another local classname.
+
+```css
+:local(.className) {
+ background: red;
+ color: yellow;
+}
+
+:local(.subClass) {
+ composes: className;
+ background: blue;
+}
+```
+
+This doesn't result in any change to the CSS itself but exports multiple classnames.
+
+```js
+exports.locals = {
+ className: "_23_aKvs-b8bW2Vg3fwHozO",
+ subClass: "_13LGdX8RMStbBE9w-t0gZ1 _23_aKvs-b8bW2Vg3fwHozO",
+};
+```
+
+```css
+._23_aKvs-b8bW2Vg3fwHozO {
+ background: red;
+ color: yellow;
+}
+
+._13LGdX8RMStbBE9w-t0gZ1 {
+ background: blue;
+}
+```
+
+##### `Importing`
+
+To import a local classname from another module.
+
+> **Note**
+>
+> We strongly recommend that you specify the extension when importing a file, since it is possible to import a file with any extension and it is not known in advance which file to use.
+
+```css
+:local(.continueButton) {
+ composes: button from "library/button.css";
+ background: red;
+}
+```
+
+```css
+:local(.nameEdit) {
+ composes: edit highlight from "./edit.css";
+ background: red;
+}
+```
+
+To import from multiple modules use multiple `composes:` rules.
+
+```css
+:local(.className) {
+ composes: edit highlight from "./edit.css", button from "module/button.css", classFromThisModule;
+ background: red;
+}
+```
+
+or
+
+```css
+:local(.className) {
+ composes: edit highlight from "./edit.css";
+ composes: button from "module/button.css";
+ composes: classFromThisModule;
+ background: red;
+}
+```
+
+##### `Values`
+
+You can use `@value` to specific values to be reused throughout a document.
+
+We recommend use prefix `v-` for values, `s-` for selectors and `m-` for media at-rules.
+
+```css
+@value v-primary: #BF4040;
+@value s-black: black-selector;
+@value m-large: (min-width: 960px);
+
+.header {
+ color: v-primary;
+ padding: 0 10px;
+}
+
+.s-black {
+ color: black;
+}
+
+@media m-large {
+ .header {
+ padding: 0 20px;
+ }
+}
+```
+
+#### `boolean`
+
+Enable **CSS Modules** features.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: true,
+ },
+ },
+ ],
+ },
+};
+```
+
+#### `string`
+
+Enable **CSS Modules** features and setup `mode`.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ // Using `local` value has same effect like using `modules: true`
+ modules: "global",
+ },
+ },
+ ],
+ },
+};
+```
+
+#### `object`
+
+Enable **CSS Modules** features and setup options for them.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ mode: "local",
+ auto: true,
+ exportGlobals: true,
+ localIdentName: "[path][name]__[local]--[hash:base64:5]",
+ localIdentContext: path.resolve(__dirname, "src"),
+ localIdentHashSalt: "my-custom-hash",
+ namedExport: true,
+ exportLocalsConvention: "camelCase",
+ exportOnlyLocals: false,
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `auto`
+
+Type:
+
+```ts
+type auto =
+ | boolean
+ | regExp
+ | ((
+ resourcePath: string,
+ resourceQuery: string,
+ resourceFragment: string
+ ) => boolean);
+```
+
+Default: `undefined`
+
+Allows auto enable CSS modules/ICSS based on the filename, query or fragment when `modules` option is object.
+
+Possible values:
+
+- `undefined` - enable CSS modules for all files.
+- `true` - enable CSS modules for all files matching `/\.module\.\w+$/i.test(filename)` and `/\.icss\.\w+$/i.test(filename)` regexp.
+- `false` - disables CSS Modules.
+- `RegExp` - enable CSS modules for all files matching `/RegExp/i.test(filename)` regexp.
+- `function` - enable CSS Modules for files based on the filename satisfying your filter function check.
+
+###### `boolean`
+
+Possible values:
+
+- `true` - enables CSS modules or interoperable CSS format, sets the [`modules.mode`](#mode) option to `local` value for all files which satisfy `/\.module(s)?\.\w+$/i.test(filename)` condition or sets the [`modules.mode`](#mode) option to `icss` value for all files which satisfy `/\.icss\.\w+$/i.test(filename)` condition
+- `false` - disables CSS modules or interoperable CSS format based on filename
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ auto: true,
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+###### `RegExp`
+
+Enable CSS modules for files based on the filename satisfying your regex check.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ auto: /\.custom-module\.\w+$/i,
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+###### `function`
+
+Enable CSS modules for files based on the filename, query or fragment satisfying your filter function check.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ auto: (resourcePath, resourceQuery, resourceFragment) => {
+ return resourcePath.endsWith(".custom-module.css");
+ },
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `mode`
+
+Type:
+
+```ts
+type mode =
+ | "local"
+ | "global"
+ | "pure"
+ | "icss"
+ | ((
+ resourcePath: string,
+ resourceQuery: string,
+ resourceFragment: string
+ ) => "local" | "global" | "pure" | "icss");
+```
+
+Default: `'local'`
+
+Setup `mode` option. You can omit the value when you want `local` mode.
+
+Controls the level of compilation applied to the input styles.
+
+The `local`, `global`, and `pure` handles `class` and `id` scoping and `@value` values.
+The `icss` will only compile the low level `Interoperable CSS` format for declaring `:import` and `:export` dependencies between CSS and other languages.
+
+ICSS underpins CSS Module support, and provides a low level syntax for other tools to implement CSS-module variations of their own.
+
+###### `string`
+
+Possible values - `local`, `global`, `pure`, and `icss`.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ mode: "global",
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+###### `function`
+
+Allows set different values for the `mode` option based on the filename, query or fragment.
+
+Possible return values - `local`, `global`, `pure` and `icss`.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ // Callback must return "local", "global", or "pure" values
+ mode: (resourcePath, resourceQuery, resourceFragment) => {
+ if (/pure.css$/i.test(resourcePath)) {
+ return "pure";
+ }
+
+ if (/global.css$/i.test(resourcePath)) {
+ return "global";
+ }
+
+ return "local";
+ },
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `localIdentName`
+
+Type:
+
+```ts
+type localIdentName = string;
+```
+
+Default: `'[hash:base64]'`
+
+Allows to configure the generated local ident name.
+
+For more information on options see:
+
+- [webpack template strings](https://webpack.js.org/configuration/output/#template-strings),
+- [output.hashDigest](https://webpack.js.org/configuration/output/#outputhashdigest),
+- [output.hashDigestLength](https://webpack.js.org/configuration/output/#outputhashdigestlength),
+- [output.hashFunction](https://webpack.js.org/configuration/output/#outputhashfunction),
+- [output.hashSalt](https://webpack.js.org/configuration/output/#outputhashsalt).
+
+Supported template strings:
+
+- `[name]` the basename of the resource
+- `[folder]` the folder the resource relative to the `compiler.context` option or `modules.localIdentContext` option.
+- `[path]` the path of the resource relative to the `compiler.context` option or `modules.localIdentContext` option.
+- `[file]` - filename and path.
+- `[ext]` - extension with leading `.`.
+- `[hash]` - the hash of the string, generated based on `localIdentHashSalt`, `localIdentHashFunction`, `localIdentHashDigest`, `localIdentHashDigestLength`, `localIdentContext`, `resourcePath` and `exportName`
+- `[:hash::]` - hash with hash settings.
+- `[local]` - original class.
+
+Recommendations:
+
+- use `'[path][name]__[local]'` for development
+- use `'[hash:base64]'` for production
+
+The `[local]` placeholder contains original class.
+
+**Note:** all reserved (`<>:"/\|?*`) and control filesystem characters (excluding characters in the `[local]` placeholder) will be converted to `-`.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ localIdentName: "[path][name]__[local]--[hash:base64:5]",
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `localIdentContext`
+
+Type:
+
+```ts
+type localIdentContex = string;
+```
+
+Default: `compiler.context`
+
+Allows to redefine basic loader context for local ident name.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ localIdentContext: path.resolve(__dirname, "src"),
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `localIdentHashSalt`
+
+Type:
+
+```ts
+type localIdentHashSalt = string;
+```
+
+Default: `undefined`
+
+Allows to add custom hash to generate more unique classes.
+For more information see [output.hashSalt](https://webpack.js.org/configuration/output/#outputhashsalt).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ localIdentHashSalt: "hash",
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `localIdentHashFunction`
+
+Type:
+
+```ts
+type localIdentHashFunction = string;
+```
+
+Default: `md4`
+
+Allows to specify hash function to generate classes .
+For more information see [output.hashFunction](https://webpack.js.org/configuration/output/#outputhashfunction).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ localIdentHashFunction: "md4",
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `localIdentHashDigest`
+
+Type:
+
+```ts
+type localIdentHashDigest = string;
+```
+
+Default: `hex`
+
+Allows to specify hash digest to generate classes.
+For more information see [output.hashDigest](https://webpack.js.org/configuration/output/#outputhashdigest).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ localIdentHashDigest: "base64",
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `localIdentHashDigestLength`
+
+Type:
+
+```ts
+type localIdentHashDigestLength = number;
+```
+
+Default: `20`
+
+Allows to specify hash digest length to generate classes.
+For more information see [output.hashDigestLength](https://webpack.js.org/configuration/output/#outputhashdigestlength).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ localIdentHashDigestLength: 5,
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `hashStrategy`
+
+Type: `'resource-path-and-local-name' | 'minimal-subset'`
+Default: `'resource-path-and-local-name'`
+
+Should local name be used when computing the hash.
+
+- `'resource-path-and-local-name'` Both resource path and local name are used when hashing. Each identifier in a module gets its own hash digest, always.
+- `'minimal-subset'` Auto detect if identifier names can be omitted from hashing. Use this value to optimize the output for better GZIP or Brotli compression.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ hashStrategy: "minimal-subset",
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `localIdentRegExp`
+
+Type:
+
+```ts
+type localIdentRegExp = string | RegExp;
+```
+
+Default: `undefined`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ localIdentRegExp: /page-(.*)\.css/i,
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `getLocalIdent`
+
+Type:
+
+```ts
+type getLocalIdent = (
+ context: LoaderContext,
+ localIdentName: string,
+ localName: string
+) => string;
+```
+
+Default: `undefined`
+
+Allows to specify a function to generate the classname.
+By default we use built-in function to generate a classname.
+If the custom function returns `null` or `undefined`, we fallback to the
+built-in function to generate the classname.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ getLocalIdent: (context, localIdentName, localName, options) => {
+ return "whatever_random_class_name";
+ },
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `namedExport`
+
+Type:
+
+```ts
+type namedExport = boolean;
+```
+
+Default: `false`
+
+Enables/disables ES modules named export for locals.
+
+> **Warning**
+>
+> Names of locals are converted to camelcase, i.e. the `exportLocalsConvention` option has
+> `camelCaseOnly` value by default. You can set this back to any other valid option but selectors
+> which are not valid JavaScript identifiers may run into problems which do not implement the entire
+> modules specification.
+
+> **Warning**
+>
+> It is not allowed to use JavaScript reserved words in css class names unless
+> `exportLocalsConvention` is `"asIs"`.
+
+**styles.css**
+
+```css
+.foo-baz {
+ color: red;
+}
+.bar {
+ color: blue;
+}
+```
+
+**index.js**
+
+```js
+import * as styles from "./styles.css";
+
+console.log(styles.fooBaz, styles.bar);
+// or if using `exportLocalsConvention: "asIs"`:
+console.log(styles["foo-baz"], styles.bar);
+```
+
+You can enable a ES module named export using:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ esModule: true,
+ modules: {
+ namedExport: true,
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+To set a custom name for namedExport, can use [`exportLocalsConvention`](#exportLocalsConvention) option as a function.
+Example below in the [`examples`](#examples) section.
+
+##### `exportGlobals`
+
+Type:
+
+```ts
+type exportsGLobals = boolean;
+```
+
+Default: `false`
+
+Allow `css-loader` to export names from global class or id, so you can use that as local name.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ exportGlobals: true,
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `exportLocalsConvention`
+
+Type:
+
+```ts
+type exportLocalsConvention =
+ | "asIs"
+ | "camelCase"
+ | "camelCaseOnly"
+ | "dashes"
+ | "dashesOnly"
+ | ((name: string) => string);
+```
+
+Default: based on the `modules.namedExport` option value, if `true` - `camelCaseOnly`, otherwise `asIs`
+
+Style of exported class names.
+
+###### `string`
+
+By default, the exported JSON keys mirror the class names (i.e `asIs` value).
+
+| Name | Type | Description |
+| :-------------------: | :------: | :----------------------------------------------------------------------------------------------- |
+| **`'asIs'`** | `string` | Class names will be exported as is. |
+| **`'camelCase'`** | `string` | Class names will be camelized, the original class name will not to be removed from the locals |
+| **`'camelCaseOnly'`** | `string` | Class names will be camelized, the original class name will be removed from the locals |
+| **`'dashes'`** | `string` | Only dashes in class names will be camelized |
+| **`'dashesOnly'`** | `string` | Dashes in class names will be camelized, the original class name will be removed from the locals |
+
+**file.css**
+
+```css
+.class-name {
+}
+```
+
+**file.js**
+
+```js
+import { className } from "file.css";
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ exportLocalsConvention: "camelCase",
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+###### `function`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ exportLocalsConvention: function (name) {
+ return name.replace(/-/g, "_");
+ },
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ exportLocalsConvention: function (name) {
+ return [
+ name.replace(/-/g, "_"),
+ // dashesCamelCase
+ name.replace(/-+(\w)/g, (match, firstLetter) =>
+ firstLetter.toUpperCase()
+ ),
+ ];
+ },
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+##### `exportOnlyLocals`
+
+Type:
+
+```ts
+type exportOnlyLocals = boolean;
+```
+
+Default: `false`
+
+Export only locals.
+
+**Useful** when you use **css modules** for pre-rendering (for example SSR).
+For pre-rendering with `mini-css-extract-plugin` you should use this option instead of `style-loader!css-loader` **in the pre-rendering bundle**.
+It doesn't embed CSS but only exports the identifier mappings.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ exportOnlyLocals: true,
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+### `importLoaders`
+
+Type:
+
+```ts
+type importLoaders = number;
+```
+
+Default: `0`
+
+Allows to enables/disables or setups number of loaders applied before CSS loader for `@import` at-rules, CSS modules and ICSS imports, i.e. `@import`/`composes`/`@value value from './values.css'`/etc.
+
+The option `importLoaders` allows you to configure how many loaders before `css-loader` should be applied to `@import`ed resources and CSS modules/ICSS imports.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ use: [
+ "style-loader",
+ {
+ loader: "css-loader",
+ options: {
+ importLoaders: 2,
+ // 0 => no loaders (default);
+ // 1 => postcss-loader;
+ // 2 => postcss-loader, sass-loader
+ },
+ },
+ "postcss-loader",
+ "sass-loader",
+ ],
+ },
+ ],
+ },
+};
+```
+
+This may change in the future when the module system (i. e. webpack) supports loader matching by origin.
+
+### `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: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ sourceMap: true,
+ },
+ },
+ ],
+ },
+};
+```
+
+### `esModule`
+
+Type:
+
+```ts
+type esModule = boolean;
+```
+
+Default: `true`
+
+By default, `css-loader` generates JS modules that use the ES modules syntax.
+There are some cases in which using ES modules is beneficial, like in the case of [module concatenation](https://webpack.js.org/plugins/module-concatenation-plugin/) and [tree shaking](https://webpack.js.org/guides/tree-shaking/).
+
+You can enable a CommonJS modules syntax using:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ esModule: false,
+ },
+ },
+ ],
+ },
+};
+```
+
+### `exportType`
+
+Type:
+
+```ts
+type exportType = "array" | "string" | "css-style-sheet";
+```
+
+Default: `'array'`
+
+Allows exporting styles as array with modules, string or [constructable stylesheet](https://developers.google.com/web/updates/2019/02/constructable-stylesheets) (i.e. [`CSSStyleSheet`](https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet)).
+Default value is `'array'`, i.e. loader exports array of modules with specific API which is used in `style-loader` or other.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ assert: { type: "css" },
+ loader: "css-loader",
+ options: {
+ exportType: "css-style-sheet",
+ },
+ },
+ ],
+ },
+};
+```
+
+**src/index.js**
+
+```js
+import sheet from "./styles.css" assert { type: "css" };
+
+document.adoptedStyleSheets = [sheet];
+shadowRoot.adoptedStyleSheets = [sheet];
+```
+
+#### `'array'`
+
+The default export is array of modules with specific API which is used in `style-loader` or other.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.(sa|sc|c)ss$/i,
+ use: ["style-loader", "css-loader", "postcss-loader", "sass-loader"],
+ },
+ ],
+ },
+};
+```
+
+**src/index.js**
+
+```js
+// `style-loader` applies styles to DOM
+import "./styles.css";
+```
+
+#### `'string'`
+
+> **Warning**
+>
+> You should not use [`style-loader`](https://github.com/webpack-contrib/style-loader) or [`mini-css-extract-plugin`](https://github.com/webpack-contrib/mini-css-extract-plugin) with this value.
+
+> **Warning**
+>
+> The `esModule` option should be enabled if you want to use it with [`CSS modules`](https://github.com/webpack-contrib/css-loader#modules), by default for locals will be used [named export](https://github.com/webpack-contrib/css-loader#namedexport).
+
+The default export is `string`.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.(sa|sc|c)ss$/i,
+ use: ["css-loader", "postcss-loader", "sass-loader"],
+ },
+ ],
+ },
+};
+```
+
+**src/index.js**
+
+```js
+import sheet from "./styles.css";
+
+console.log(sheet);
+```
+
+#### `'css-style-sheet'`
+
+> **Warning**
+>
+> `@import` rules not yet allowed, more [information](https://web.dev/css-module-scripts/#@import-rules-not-yet-allowed)
+
+> **Warning**
+>
+> You don't need [`style-loader`](https://github.com/webpack-contrib/style-loader) anymore, please remove it.
+
+> **Warning**
+>
+> The `esModule` option should be enabled if you want to use it with [`CSS modules`](https://github.com/webpack-contrib/css-loader#modules), by default for locals will be used [named export](https://github.com/webpack-contrib/css-loader#namedexport).
+
+> **Warning**
+>
+> Source maps are not currently supported in `Chrome` due [bug](https://bugs.chromium.org/p/chromium/issues/detail?id=1174094&q=CSSStyleSheet%20source%20maps&can=2)
+
+The default export is a [constructable stylesheet](https://developers.google.com/web/updates/2019/02/constructable-stylesheets) (i.e. [`CSSStyleSheet`](https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet)).
+
+Useful for [custom elements](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements) and shadow DOM.
+
+More information:
+
+- [Using CSS Module Scripts to import stylesheets](https://web.dev/css-module-scripts/)
+- [Constructable Stylesheets: seamless reusable styles](https://developers.google.com/web/updates/2019/02/constructable-stylesheets)
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ assert: { type: "css" },
+ loader: "css-loader",
+ options: {
+ exportType: "css-style-sheet",
+ },
+ },
+
+ // For Sass/SCSS:
+ //
+ // {
+ // assert: { type: "css" },
+ // rules: [
+ // {
+ // loader: "css-loader",
+ // options: {
+ // exportType: "css-style-sheet",
+ // // Other options
+ // },
+ // },
+ // {
+ // loader: "sass-loader",
+ // options: {
+ // // Other options
+ // },
+ // },
+ // ],
+ // },
+ ],
+ },
+};
+```
+
+**src/index.js**
+
+```js
+// Example for Sass/SCSS:
+// import sheet from "./styles.scss" assert { type: "css" };
+
+// Example for CSS modules:
+// import sheet, { myClass } from "./styles.scss" assert { type: "css" };
+
+// Example for CSS:
+import sheet from "./styles.css" assert { type: "css" };
+
+document.adoptedStyleSheets = [sheet];
+shadowRoot.adoptedStyleSheets = [sheet];
+```
+
+For migration purposes, you can use the following configuration:
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ oneOf: [
+ {
+ assert: { type: "css" },
+ loader: "css-loader",
+ options: {
+ exportType: "css-style-sheet",
+ // Other options
+ },
+ },
+ {
+ use: [
+ "style-loader",
+ {
+ loader: "css-loader",
+ options: {
+ // Other options
+ },
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ },
+};
+```
+
+## Examples
+
+### Recommend
+
+For `production` builds it's recommended to extract the CSS from your bundle being able to use parallel loading of CSS/JS resources later on.
+This can be achieved by using the [mini-css-extract-plugin](https://github.com/webpack-contrib/mini-css-extract-plugin), because it creates separate css files.
+For `development` mode (including `webpack-dev-server`) you can use [style-loader](https://github.com/webpack-contrib/style-loader), because it injects CSS into the DOM using multiple `` and works faster.
+
+> **Note**
+>
+> Do not use `style-loader` and `mini-css-extract-plugin` together.
+
+**webpack.config.js**
+
+```js
+const MiniCssExtractPlugin = require("mini-css-extract-plugin");
+const devMode = process.env.NODE_ENV !== "production";
+
+module.exports = {
+ module: {
+ rules: [
+ {
+ // If you enable `experiments.css` or `experiments.futureDefaults`, please uncomment line below
+ // type: "javascript/auto",
+ test: /\.(sa|sc|c)ss$/i,
+ use: [
+ devMode ? "style-loader" : MiniCssExtractPlugin.loader,
+ "css-loader",
+ "postcss-loader",
+ "sass-loader",
+ ],
+ },
+ ],
+ },
+ plugins: [].concat(devMode ? [] : [new MiniCssExtractPlugin()]),
+};
+```
+
+### Disable url resolving using the `/* webpackIgnore: true */` comment
+
+With the help of the `/* webpackIgnore: true */`comment, it is possible to disable sources handling for rules and for individual declarations.
+
+```css
+/* webpackIgnore: true */
+@import url(./basic.css);
+@import /* webpackIgnore: true */ url(./imported.css);
+
+.class {
+ /* Disabled url handling for the all urls in the 'background' declaration */
+ color: red;
+ /* webpackIgnore: true */
+ background: url("./url/img.png"), url("./url/img.png");
+}
+
+.class {
+ /* Disabled url handling for the first url in the 'background' declaration */
+ color: red;
+ background:
+ /* webpackIgnore: true */ url("./url/img.png"), url("./url/img.png");
+}
+
+.class {
+ /* Disabled url handling for the second url in the 'background' declaration */
+ color: red;
+ background: url("./url/img.png"),
+ /* webpackIgnore: true */ url("./url/img.png");
+}
+
+/* prettier-ignore */
+.class {
+ /* Disabled url handling for the second url in the 'background' declaration */
+ color: red;
+ background: url("./url/img.png"),
+ /* webpackIgnore: true */
+ url("./url/img.png");
+}
+
+/* prettier-ignore */
+.class {
+ /* Disabled url handling for third and sixth urls in the 'background-image' declaration */
+ background-image: image-set(
+ url(./url/img.png) 2x,
+ url(./url/img.png) 3x,
+ /* webpackIgnore: true */ url(./url/img.png) 4x,
+ url(./url/img.png) 5x,
+ url(./url/img.png) 6x,
+ /* webpackIgnore: true */
+ url(./url/img.png) 7x
+ );
+}
+```
+
+### Assets
+
+The following `webpack.config.js` can load CSS files, embed small PNG/JPG/GIF/SVG images as well as fonts as [Data URLs](https://tools.ietf.org/html/rfc2397) and copy larger files to the output directory.
+
+**For webpack v5:**
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ use: ["style-loader", "css-loader"],
+ },
+ {
+ test: /\.(png|jpe?g|gif|svg|eot|ttf|woff|woff2)$/i,
+ // More information here https://webpack.js.org/guides/asset-modules/
+ type: "asset",
+ },
+ ],
+ },
+};
+```
+
+### Extract
+
+For production builds it's recommended to extract the CSS from your bundle being able to use parallel loading of CSS/JS resources later on.
+
+- This can be achieved by using the [mini-css-extract-plugin](https://github.com/webpack-contrib/mini-css-extract-plugin) to extract the CSS when running in production mode.
+
+- As an alternative, if seeking better development performance and css outputs that mimic production. [extract-css-chunks-webpack-plugin](https://github.com/faceyspacey/extract-css-chunks-webpack-plugin) offers a hot module reload friendly, extended version of mini-css-extract-plugin. HMR real CSS files in dev, works like mini-css in non-dev
+
+### Pure CSS, CSS modules and PostCSS
+
+When you have pure CSS (without CSS modules), CSS modules and PostCSS in your project you can use this setup:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ // For pure CSS - /\.css$/i,
+ // For Sass/SCSS - /\.((c|sa|sc)ss)$/i,
+ // For Less - /\.((c|le)ss)$/i,
+ test: /\.((c|sa|sc)ss)$/i,
+ use: [
+ "style-loader",
+ {
+ loader: "css-loader",
+ options: {
+ // Run `postcss-loader` on each CSS `@import` and CSS modules/ICSS imports, do not forget that `sass-loader` compile non CSS `@import`'s into a single file
+ // If you need run `sass-loader` and `postcss-loader` on each CSS `@import` please set it to `2`
+ importLoaders: 1,
+ },
+ },
+ {
+ loader: "postcss-loader",
+ options: { plugins: () => [postcssPresetEnv({ stage: 0 })] },
+ },
+ // Can be `less-loader`
+ {
+ loader: "sass-loader",
+ },
+ ],
+ },
+ // For webpack v5
+ {
+ test: /\.(png|jpe?g|gif|svg|eot|ttf|woff|woff2)$/i,
+ // More information here https://webpack.js.org/guides/asset-modules/
+ type: "asset",
+ },
+ ],
+ },
+};
+```
+
+### Resolve unresolved URLs using an alias
+
+**index.css**
+
+```css
+.class {
+ background: url(/assets/unresolved/img.png);
+}
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ use: ["style-loader", "css-loader"],
+ },
+ ],
+ },
+ resolve: {
+ alias: {
+ "/assets/unresolved/img.png": path.resolve(
+ __dirname,
+ "assets/real-path-to-img/img.png"
+ ),
+ },
+ },
+};
+```
+
+### Named export with custom export names
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ {
+ test: /\.css$/i,
+ loader: "css-loader",
+ options: {
+ modules: {
+ namedExport: true,
+ exportLocalsConvention: function (name) {
+ return name.replace(/-/g, "_");
+ },
+ },
+ },
+ },
+ ],
+ },
+};
+```
+
+### Separating `Interoperable CSS`-only and `CSS Module` features
+
+The following setup is an example of allowing `Interoperable CSS` features only (such as `:import` and `:export`) without using further `CSS Module` functionality by setting `mode` option for all files that do not match `*.module.scss` naming convention. This is for reference as having `ICSS` features applied to all files was default `css-loader` behavior before v4.
+Meanwhile all files matching `*.module.scss` are treated as `CSS Modules` in this example.
+
+An example case is assumed where a project requires canvas drawing variables to be synchronized with CSS - canvas drawing uses the same color (set by color name in JavaScript) as HTML background (set by class name in CSS).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+ module: {
+ rules: [
+ // ...
+ // --------
+ // SCSS ALL EXCEPT MODULES
+ {
+ test: /\.scss$/i,
+ exclude: /\.module\.scss$/i,
+ use: [
+ {
+ loader: "style-loader",
+ },
+ {
+ loader: "css-loader",
+ options: {
+ importLoaders: 1,
+ modules: {
+ mode: "icss",
+ },
+ },
+ },
+ {
+ loader: "sass-loader",
+ },
+ ],
+ },
+ // --------
+ // SCSS MODULES
+ {
+ test: /\.module\.scss$/i,
+ use: [
+ {
+ loader: "style-loader",
+ },
+ {
+ loader: "css-loader",
+ options: {
+ importLoaders: 1,
+ modules: {
+ mode: "local",
+ },
+ },
+ },
+ {
+ loader: "sass-loader",
+ },
+ ],
+ },
+ // --------
+ // ...
+ ],
+ },
+};
+```
+
+**variables.scss**
+
+File treated as `ICSS`-only.
+
+```scss
+$colorBackground: red;
+:export {
+ colorBackgroundCanvas: $colorBackground;
+}
+```
+
+**Component.module.scss**
+
+File treated as `CSS Module`.
+
+```scss
+@import "variables.scss";
+.componentClass {
+ background-color: $colorBackground;
+}
+```
+
+**Component.jsx**
+
+Using both `CSS Module` functionality as well as SCSS variables directly in JavaScript.
+
+```jsx
+import svars from "variables.scss";
+import styles from "Component.module.scss";
+
+// Render DOM with CSS modules class name
+//
+//
+
+// Somewhere in JavaScript canvas drawing code use the variable directly
+// const ctx = mountsCanvas.current.getContext('2d',{alpha: false});
+ctx.fillStyle = `${svars.colorBackgroundCanvas}`;
+```
+
+## 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/css-loader.svg
+[npm-url]: https://npmjs.com/package/css-loader
+[node]: https://img.shields.io/node/v/css-loader.svg
+[node-url]: https://nodejs.org
+[tests]: https://github.com/webpack-contrib/css-loader/workflows/css-loader/badge.svg
+[tests-url]: https://github.com/webpack-contrib/css-loader/actions
+[cover]: https://codecov.io/gh/webpack-contrib/css-loader/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/css-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=css-loader
+[size-url]: https://packagephobia.now.sh/result?p=css-loader
Index: frontend/node_modules/css-loader/dist/cjs.js
===================================================================
--- frontend/node_modules/css-loader/dist/cjs.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/cjs.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,5 @@
+"use strict";
+
+const loader = require("./index");
+module.exports = loader.default;
+module.exports.defaultGetLocalIdent = require("./utils").defaultGetLocalIdent;
Index: frontend/node_modules/css-loader/dist/index.js
===================================================================
--- frontend/node_modules/css-loader/dist/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = loader;
+var _postcss = _interopRequireDefault(require("postcss"));
+var _package = _interopRequireDefault(require("postcss/package.json"));
+var _semver = require("semver");
+var _options = _interopRequireDefault(require("./options.json"));
+var _plugins = require("./plugins");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+async function loader(content, map, meta) {
+ const rawOptions = this.getOptions(_options.default);
+ const callback = this.async();
+ if (this._compiler && this._compiler.options && this._compiler.options.experiments && this._compiler.options.experiments.css && this._module && (this._module.type === "css" || this._module.type === "css/auto" || this._module.type === "css/global" || this._module.type === "css/module")) {
+ this.emitWarning(new Error('You can\'t use `experiments.css` (`experiments.futureDefaults` enable built-in CSS support by default) and `css-loader` together, please set `experiments.css` to `false` or set `{ type: "javascript/auto" }` for rules with `css-loader` in your webpack config (now css-loader does nothing).'));
+ callback(null, content, map, meta);
+ return;
+ }
+ let options;
+ try {
+ options = (0, _utils.normalizeOptions)(rawOptions, this);
+ } catch (error) {
+ callback(error);
+ return;
+ }
+ const plugins = [];
+ const replacements = [];
+ const exports = [];
+ if ((0, _utils.shouldUseModulesPlugins)(options)) {
+ plugins.push(...(0, _utils.getModulesPlugins)(options, this));
+ }
+ const importPluginImports = [];
+ const importPluginApi = [];
+ let isSupportAbsoluteURL = false;
+
+ // TODO enable by default in the next major release
+ if (this._compilation && this._compilation.options && this._compilation.options.experiments && this._compilation.options.experiments.buildHttp) {
+ isSupportAbsoluteURL = true;
+ }
+ const isSupportDataURL = options.esModule && Boolean("fsStartTime" in this._compiler);
+ if ((0, _utils.shouldUseImportPlugin)(options)) {
+ plugins.push((0, _plugins.importParser)({
+ isSupportAbsoluteURL: false,
+ isSupportDataURL: false,
+ isCSSStyleSheet: options.exportType === "css-style-sheet",
+ loaderContext: this,
+ imports: importPluginImports,
+ api: importPluginApi,
+ filter: options.import.filter,
+ urlHandler: url => (0, _utils.stringifyRequest)(this, (0, _utils.combineRequests)((0, _utils.getPreRequester)(this)(options.importLoaders), url))
+ }));
+ }
+ const urlPluginImports = [];
+ if ((0, _utils.shouldUseURLPlugin)(options)) {
+ const needToResolveURL = !options.esModule;
+ plugins.push((0, _plugins.urlParser)({
+ isSupportAbsoluteURL,
+ isSupportDataURL,
+ imports: urlPluginImports,
+ replacements,
+ context: this.context,
+ rootContext: this.rootContext,
+ filter: (0, _utils.getFilter)(options.url.filter, this.resourcePath),
+ resolver: needToResolveURL ? this.getResolve({
+ mainFiles: [],
+ extensions: []
+ }) :
+ // eslint-disable-next-line no-undefined
+ undefined,
+ urlHandler: url => (0, _utils.stringifyRequest)(this, url)
+ // Support data urls as input in new URL added in webpack@5.38.0
+ }));
+ }
+ const icssPluginImports = [];
+ const icssPluginApi = [];
+ const needToUseIcssPlugin = (0, _utils.shouldUseIcssPlugin)(options);
+ if (needToUseIcssPlugin) {
+ plugins.push((0, _plugins.icssParser)({
+ loaderContext: this,
+ imports: icssPluginImports,
+ api: icssPluginApi,
+ replacements,
+ exports,
+ urlHandler: url => (0, _utils.stringifyRequest)(this, (0, _utils.combineRequests)((0, _utils.getPreRequester)(this)(options.importLoaders), url))
+ }));
+ }
+
+ // Reuse CSS AST (PostCSS AST e.g 'postcss-loader') to avoid reparsing
+ if (meta) {
+ const {
+ ast
+ } = meta;
+ if (ast && ast.type === "postcss" && (0, _semver.satisfies)(ast.version, `^${_package.default.version}`)) {
+ // eslint-disable-next-line no-param-reassign
+ content = ast.root;
+ }
+ }
+ const {
+ resourcePath
+ } = this;
+ let result;
+ try {
+ result = await (0, _postcss.default)(plugins).process(content, {
+ hideNothingWarning: true,
+ from: resourcePath,
+ to: resourcePath,
+ map: options.sourceMap ? {
+ prev: map ? (0, _utils.normalizeSourceMap)(map, resourcePath) : null,
+ inline: false,
+ annotation: false
+ } : false
+ });
+ } catch (error) {
+ if (error.file) {
+ this.addDependency(error.file);
+ }
+ callback(error.name === "CssSyntaxError" ? (0, _utils.syntaxErrorFactory)(error) : error);
+ return;
+ }
+ for (const warning of result.warnings()) {
+ this.emitWarning((0, _utils.warningFactory)(warning));
+ }
+ const imports = [].concat(icssPluginImports.sort(_utils.sort)).concat(importPluginImports.sort(_utils.sort)).concat(urlPluginImports.sort(_utils.sort));
+ const api = [].concat(importPluginApi.sort(_utils.sort)).concat(icssPluginApi.sort(_utils.sort));
+ if (options.modules.exportOnlyLocals !== true) {
+ imports.unshift({
+ type: "api_import",
+ importName: "___CSS_LOADER_API_IMPORT___",
+ url: (0, _utils.stringifyRequest)(this, require.resolve("./runtime/api"))
+ });
+ if (options.sourceMap) {
+ imports.unshift({
+ importName: "___CSS_LOADER_API_SOURCEMAP_IMPORT___",
+ url: (0, _utils.stringifyRequest)(this, require.resolve("./runtime/sourceMaps"))
+ });
+ } else {
+ imports.unshift({
+ importName: "___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___",
+ url: (0, _utils.stringifyRequest)(this, require.resolve("./runtime/noSourceMaps"))
+ });
+ }
+ }
+ let isTemplateLiteralSupported = false;
+ if (
+ // eslint-disable-next-line no-underscore-dangle
+ this._compilation &&
+ // eslint-disable-next-line no-underscore-dangle
+ this._compilation.options &&
+ // eslint-disable-next-line no-underscore-dangle
+ this._compilation.options.output &&
+ // eslint-disable-next-line no-underscore-dangle
+ this._compilation.options.output.environment &&
+ // eslint-disable-next-line no-underscore-dangle
+ this._compilation.options.output.environment.templateLiteral) {
+ isTemplateLiteralSupported = true;
+ }
+ const importCode = (0, _utils.getImportCode)(imports, options);
+ let moduleCode;
+ try {
+ moduleCode = (0, _utils.getModuleCode)(result, api, replacements, options, isTemplateLiteralSupported, this);
+ } catch (error) {
+ callback(error);
+ return;
+ }
+ const exportCode = (0, _utils.getExportCode)(exports, replacements, needToUseIcssPlugin, options, isTemplateLiteralSupported);
+ callback(null, `${importCode}${moduleCode}${exportCode}`);
+}
Index: frontend/node_modules/css-loader/dist/options.json
===================================================================
--- frontend/node_modules/css-loader/dist/options.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/options.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,209 @@
+{
+ "title": "CSS Loader options",
+ "additionalProperties": false,
+ "properties": {
+ "url": {
+ "description": "Allows to enables/disables `url()`/`image-set()` functions handling.",
+ "link": "https://github.com/webpack-contrib/css-loader#url",
+ "anyOf": [
+ {
+ "type": "boolean"
+ },
+ {
+ "type": "object",
+ "properties": {
+ "filter": {
+ "instanceof": "Function"
+ }
+ },
+ "additionalProperties": false
+ }
+ ]
+ },
+ "import": {
+ "description": "Allows to enables/disables `@import` at-rules handling.",
+ "link": "https://github.com/webpack-contrib/css-loader#import",
+ "anyOf": [
+ {
+ "type": "boolean"
+ },
+ {
+ "type": "object",
+ "properties": {
+ "filter": {
+ "instanceof": "Function"
+ }
+ },
+ "additionalProperties": false
+ }
+ ]
+ },
+ "modules": {
+ "description": "Allows to enable/disable CSS Modules or ICSS and setup configuration.",
+ "link": "https://github.com/webpack-contrib/css-loader#modules",
+ "anyOf": [
+ {
+ "type": "boolean"
+ },
+ {
+ "enum": ["local", "global", "pure", "icss"]
+ },
+ {
+ "type": "object",
+ "additionalProperties": false,
+ "properties": {
+ "auto": {
+ "description": "Allows auto enable CSS modules based on filename.",
+ "link": "https://github.com/webpack-contrib/css-loader#auto",
+ "anyOf": [
+ {
+ "instanceof": "RegExp"
+ },
+ {
+ "instanceof": "Function"
+ },
+ {
+ "type": "boolean"
+ }
+ ]
+ },
+ "mode": {
+ "description": "Setup `mode` option.",
+ "link": "https://github.com/webpack-contrib/css-loader#mode",
+ "anyOf": [
+ {
+ "enum": ["local", "global", "pure", "icss"]
+ },
+ {
+ "instanceof": "Function"
+ }
+ ]
+ },
+ "localIdentName": {
+ "description": "Allows to configure the generated local ident name.",
+ "link": "https://github.com/webpack-contrib/css-loader#localidentname",
+ "type": "string",
+ "minLength": 1
+ },
+ "localIdentContext": {
+ "description": "Allows to redefine basic loader context for local ident name.",
+ "link": "https://github.com/webpack-contrib/css-loader#localidentcontext",
+ "type": "string",
+ "minLength": 1
+ },
+ "localIdentHashSalt": {
+ "description": "Allows to add custom hash to generate more unique classes.",
+ "link": "https://github.com/webpack-contrib/css-loader#localidenthashsalt",
+ "type": "string",
+ "minLength": 1
+ },
+ "localIdentHashFunction": {
+ "description": "Allows to specify hash function to generate classes.",
+ "link": "https://github.com/webpack-contrib/css-loader#localidenthashfunction",
+ "type": "string",
+ "minLength": 1
+ },
+ "localIdentHashDigest": {
+ "description": "Allows to specify hash digest to generate classes.",
+ "link": "https://github.com/webpack-contrib/css-loader#localidenthashdigest",
+ "type": "string",
+ "minLength": 1
+ },
+ "localIdentHashDigestLength": {
+ "description": "Allows to specify hash digest length to generate classes.",
+ "link": "https://github.com/webpack-contrib/css-loader#localidenthashdigestlength",
+ "type": "number"
+ },
+ "hashStrategy": {
+ "description": "Allows to specify should localName be used when computing the hash.",
+ "link": "https://github.com/webpack-contrib/css-loader#hashstrategy",
+ "enum": ["resource-path-and-local-name", "minimal-subset"]
+ },
+ "localIdentRegExp": {
+ "description": "Allows to specify custom RegExp for local ident name.",
+ "link": "https://github.com/webpack-contrib/css-loader#localidentregexp",
+ "anyOf": [
+ {
+ "type": "string",
+ "minLength": 1
+ },
+ {
+ "instanceof": "RegExp"
+ }
+ ]
+ },
+ "getLocalIdent": {
+ "description": "Allows to specify a function to generate the classname.",
+ "link": "https://github.com/webpack-contrib/css-loader#getlocalident",
+ "instanceof": "Function"
+ },
+ "namedExport": {
+ "description": "Enables/disables ES modules named export for locals.",
+ "link": "https://github.com/webpack-contrib/css-loader#namedexport",
+ "type": "boolean"
+ },
+ "exportGlobals": {
+ "description": "Allows to export names from global class or id, so you can use that as local name.",
+ "link": "https://github.com/webpack-contrib/css-loader#exportglobals",
+ "type": "boolean"
+ },
+ "exportLocalsConvention": {
+ "description": "Style of exported classnames.",
+ "link": "https://github.com/webpack-contrib/css-loader#localsconvention",
+ "anyOf": [
+ {
+ "enum": [
+ "asIs",
+ "camelCase",
+ "camelCaseOnly",
+ "dashes",
+ "dashesOnly"
+ ]
+ },
+ {
+ "instanceof": "Function"
+ }
+ ]
+ },
+ "exportOnlyLocals": {
+ "description": "Export only locals.",
+ "link": "https://github.com/webpack-contrib/css-loader#exportonlylocals",
+ "type": "boolean"
+ }
+ }
+ }
+ ]
+ },
+ "sourceMap": {
+ "description": "Allows to enable/disable source maps.",
+ "link": "https://github.com/webpack-contrib/css-loader#sourcemap",
+ "type": "boolean"
+ },
+ "importLoaders": {
+ "description": "Allows enables/disables or setups number of loaders applied before CSS loader for `@import`/CSS Modules and ICSS imports.",
+ "link": "https://github.com/webpack-contrib/css-loader#importloaders",
+ "anyOf": [
+ {
+ "type": "boolean"
+ },
+ {
+ "type": "string"
+ },
+ {
+ "type": "integer"
+ }
+ ]
+ },
+ "esModule": {
+ "description": "Use the ES modules syntax.",
+ "link": "https://github.com/webpack-contrib/css-loader#esmodule",
+ "type": "boolean"
+ },
+ "exportType": {
+ "description": "Allows exporting styles as array with modules, string or constructable stylesheet (i.e. `CSSStyleSheet`).",
+ "link": "https://github.com/webpack-contrib/css-loader#exporttype",
+ "enum": ["array", "string", "css-style-sheet"]
+ }
+ },
+ "type": "object"
+}
Index: frontend/node_modules/css-loader/dist/plugins/index.js
===================================================================
--- frontend/node_modules/css-loader/dist/plugins/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/plugins/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+Object.defineProperty(exports, "icssParser", {
+ enumerable: true,
+ get: function () {
+ return _postcssIcssParser.default;
+ }
+});
+Object.defineProperty(exports, "importParser", {
+ enumerable: true,
+ get: function () {
+ return _postcssImportParser.default;
+ }
+});
+Object.defineProperty(exports, "urlParser", {
+ enumerable: true,
+ get: function () {
+ return _postcssUrlParser.default;
+ }
+});
+var _postcssImportParser = _interopRequireDefault(require("./postcss-import-parser"));
+var _postcssIcssParser = _interopRequireDefault(require("./postcss-icss-parser"));
+var _postcssUrlParser = _interopRequireDefault(require("./postcss-url-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
Index: frontend/node_modules/css-loader/dist/plugins/postcss-icss-parser.js
===================================================================
--- frontend/node_modules/css-loader/dist/plugins/postcss-icss-parser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/plugins/postcss-icss-parser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _icssUtils = require("icss-utils");
+var _utils = require("../utils");
+const plugin = (options = {}) => {
+ return {
+ postcssPlugin: "postcss-icss-parser",
+ async OnceExit(root) {
+ const importReplacements = Object.create(null);
+ const {
+ icssImports,
+ icssExports
+ } = (0, _icssUtils.extractICSS)(root);
+ const imports = new Map();
+ const tasks = [];
+ const {
+ loaderContext
+ } = options;
+ const resolver = loaderContext.getResolve({
+ dependencyType: "icss",
+ conditionNames: ["style"],
+ extensions: ["..."],
+ mainFields: ["css", "style", "main", "..."],
+ mainFiles: ["index", "..."],
+ preferRelative: true
+ });
+
+ // eslint-disable-next-line guard-for-in
+ for (const url in icssImports) {
+ const tokens = icssImports[url];
+ if (Object.keys(tokens).length === 0) {
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+ let normalizedUrl = url;
+ let prefix = "";
+ const queryParts = normalizedUrl.split("!");
+ if (queryParts.length > 1) {
+ normalizedUrl = queryParts.pop();
+ prefix = queryParts.join("!");
+ }
+ const request = (0, _utils.requestify)((0, _utils.normalizeUrl)(normalizedUrl, true), loaderContext.rootContext);
+ const doResolve = async () => {
+ const resolvedUrl = await (0, _utils.resolveRequests)(resolver, loaderContext.context, [...new Set([normalizedUrl, request])]);
+ if (!resolvedUrl) {
+ return;
+ }
+
+ // eslint-disable-next-line consistent-return
+ return {
+ url: resolvedUrl,
+ prefix,
+ tokens
+ };
+ };
+ tasks.push(doResolve());
+ }
+ const results = await Promise.all(tasks);
+ for (let index = 0; index <= results.length - 1; index++) {
+ const item = results[index];
+ if (!item) {
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+ const newUrl = item.prefix ? `${item.prefix}!${item.url}` : item.url;
+ const importKey = newUrl;
+ let importName = imports.get(importKey);
+ if (!importName) {
+ importName = `___CSS_LOADER_ICSS_IMPORT_${imports.size}___`;
+ imports.set(importKey, importName);
+ options.imports.push({
+ type: "icss_import",
+ importName,
+ url: options.urlHandler(newUrl),
+ icss: true,
+ index
+ });
+ options.api.push({
+ importName,
+ dedupe: true,
+ index
+ });
+ }
+ for (const [replacementIndex, token] of Object.keys(item.tokens).entries()) {
+ const replacementName = `___CSS_LOADER_ICSS_IMPORT_${index}_REPLACEMENT_${replacementIndex}___`;
+ const localName = item.tokens[token];
+ importReplacements[token] = replacementName;
+ options.replacements.push({
+ replacementName,
+ importName,
+ localName
+ });
+ }
+ }
+ if (Object.keys(importReplacements).length > 0) {
+ (0, _icssUtils.replaceSymbols)(root, importReplacements);
+ }
+ for (const name of Object.keys(icssExports)) {
+ const value = (0, _icssUtils.replaceValueSymbols)(icssExports[name], importReplacements);
+ options.exports.push({
+ name,
+ value
+ });
+ }
+ }
+ };
+};
+plugin.postcss = true;
+var _default = exports.default = plugin;
Index: frontend/node_modules/css-loader/dist/plugins/postcss-import-parser.js
===================================================================
--- frontend/node_modules/css-loader/dist/plugins/postcss-import-parser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/plugins/postcss-import-parser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,282 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function parseNode(atRule, key, options) {
+ // Convert only top-level @import
+ if (atRule.parent.type !== "root") {
+ return;
+ }
+ if (atRule.raws && atRule.raws.afterName && atRule.raws.afterName.trim().length > 0) {
+ const lastCommentIndex = atRule.raws.afterName.lastIndexOf("/*");
+ const matched = atRule.raws.afterName.slice(lastCommentIndex).match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+ if (matched && matched[2] === "true") {
+ return;
+ }
+ }
+ const prevNode = atRule.prev();
+ if (prevNode && prevNode.type === "comment") {
+ const matched = prevNode.text.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+ if (matched && matched[2] === "true") {
+ return;
+ }
+ }
+
+ // Nodes do not exists - `@import url('http://') :root {}`
+ if (atRule.nodes) {
+ const error = new Error("It looks like you didn't end your @import statement correctly. Child nodes are attached to it.");
+ error.node = atRule;
+ throw error;
+ }
+ const rawParams = atRule.raws && atRule.raws[key] && typeof atRule.raws[key].raw !== "undefined" ? atRule.raws[key].raw : atRule[key];
+ const {
+ nodes: paramsNodes
+ } = (0, _postcssValueParser.default)(rawParams);
+
+ // No nodes - `@import ;`
+ // Invalid type - `@import foo-bar;`
+ if (paramsNodes.length === 0 || paramsNodes[0].type !== "string" && paramsNodes[0].type !== "function") {
+ const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+ error.node = atRule;
+ throw error;
+ }
+ let isStringValue;
+ let url;
+ if (paramsNodes[0].type === "string") {
+ isStringValue = true;
+ url = paramsNodes[0].value;
+ } else {
+ // Invalid function - `@import nourl(test.css);`
+ if (paramsNodes[0].value.toLowerCase() !== "url") {
+ const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+ error.node = atRule;
+ throw error;
+ }
+ isStringValue = paramsNodes[0].nodes.length !== 0 && paramsNodes[0].nodes[0].type === "string";
+ url = isStringValue ? paramsNodes[0].nodes[0].value : _postcssValueParser.default.stringify(paramsNodes[0].nodes);
+ }
+ url = (0, _utils.normalizeUrl)(url, isStringValue);
+ const {
+ requestable,
+ needResolve
+ } = (0, _utils.isURLRequestable)(url, options);
+ let prefix;
+ if (requestable && needResolve) {
+ const queryParts = url.split("!");
+ if (queryParts.length > 1) {
+ url = queryParts.pop();
+ prefix = queryParts.join("!");
+ }
+ }
+
+ // Empty url - `@import "";` or `@import url();`
+ if (url.trim().length === 0) {
+ const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+ error.node = atRule;
+ throw error;
+ }
+ const additionalNodes = paramsNodes.slice(1);
+ let supports;
+ let layer;
+ let media;
+ if (additionalNodes.length > 0) {
+ let nodes = [];
+ for (const node of additionalNodes) {
+ nodes.push(node);
+ const isLayerFunction = node.type === "function" && node.value.toLowerCase() === "layer";
+ const isLayerWord = node.type === "word" && node.value.toLowerCase() === "layer";
+ if (isLayerFunction || isLayerWord) {
+ if (isLayerFunction) {
+ nodes.splice(nodes.length - 1, 1, ...node.nodes);
+ } else {
+ nodes.splice(nodes.length - 1, 1, {
+ type: "string",
+ value: "",
+ unclosed: false
+ });
+ }
+ layer = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+ nodes = [];
+ } else if (node.type === "function" && node.value.toLowerCase() === "supports") {
+ nodes.splice(nodes.length - 1, 1, ...node.nodes);
+ supports = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+ nodes = [];
+ }
+ }
+ if (nodes.length > 0) {
+ media = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+ }
+ }
+
+ // eslint-disable-next-line consistent-return
+ return {
+ atRule,
+ prefix,
+ url,
+ layer,
+ supports,
+ media,
+ requestable,
+ needResolve
+ };
+}
+const plugin = (options = {}) => {
+ return {
+ postcssPlugin: "postcss-import-parser",
+ prepare(result) {
+ const parsedAtRules = [];
+ return {
+ AtRule: {
+ import(atRule) {
+ if (options.isCSSStyleSheet) {
+ options.loaderContext.emitError(new Error(atRule.error("'@import' rules are not allowed here and will not be processed").message));
+ return;
+ }
+ const {
+ isSupportDataURL,
+ isSupportAbsoluteURL
+ } = options;
+ let parsedAtRule;
+ try {
+ parsedAtRule = parseNode(atRule, "params", {
+ isSupportAbsoluteURL,
+ isSupportDataURL
+ });
+ } catch (error) {
+ result.warn(error.message, {
+ node: error.node
+ });
+ }
+ if (!parsedAtRule) {
+ return;
+ }
+ parsedAtRules.push(parsedAtRule);
+ }
+ },
+ async OnceExit() {
+ if (parsedAtRules.length === 0) {
+ return;
+ }
+ const {
+ loaderContext
+ } = options;
+ const resolver = loaderContext.getResolve({
+ dependencyType: "css",
+ conditionNames: ["style"],
+ mainFields: ["css", "style", "main", "..."],
+ mainFiles: ["index", "..."],
+ extensions: [".css", "..."],
+ preferRelative: true
+ });
+ const resolvedAtRules = await Promise.all(parsedAtRules.map(async parsedAtRule => {
+ const {
+ atRule,
+ requestable,
+ needResolve,
+ prefix,
+ url,
+ layer,
+ supports,
+ media
+ } = parsedAtRule;
+ if (options.filter) {
+ const needKeep = await options.filter(url, media, loaderContext.resourcePath, supports, layer);
+ if (!needKeep) {
+ return;
+ }
+ }
+ if (needResolve) {
+ const request = (0, _utils.requestify)(url, loaderContext.rootContext);
+ const resolvedUrl = await (0, _utils.resolveRequests)(resolver, loaderContext.context, [...new Set([request, url])]);
+ if (!resolvedUrl) {
+ return;
+ }
+ if (resolvedUrl === loaderContext.resourcePath) {
+ atRule.remove();
+ return;
+ }
+ atRule.remove();
+
+ // eslint-disable-next-line consistent-return
+ return {
+ url: resolvedUrl,
+ layer,
+ supports,
+ media,
+ prefix,
+ requestable
+ };
+ }
+ atRule.remove();
+
+ // eslint-disable-next-line consistent-return
+ return {
+ url,
+ layer,
+ supports,
+ media,
+ prefix,
+ requestable
+ };
+ }));
+ const urlToNameMap = new Map();
+ for (let index = 0; index <= resolvedAtRules.length - 1; index++) {
+ const resolvedAtRule = resolvedAtRules[index];
+ if (!resolvedAtRule) {
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+ const {
+ url,
+ requestable,
+ layer,
+ supports,
+ media
+ } = resolvedAtRule;
+ if (!requestable) {
+ options.api.push({
+ url,
+ layer,
+ supports,
+ media,
+ index
+ });
+
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+ const {
+ prefix
+ } = resolvedAtRule;
+ const newUrl = prefix ? `${prefix}!${url}` : url;
+ let importName = urlToNameMap.get(newUrl);
+ if (!importName) {
+ importName = `___CSS_LOADER_AT_RULE_IMPORT_${urlToNameMap.size}___`;
+ urlToNameMap.set(newUrl, importName);
+ options.imports.push({
+ type: "rule_import",
+ importName,
+ url: options.urlHandler(newUrl),
+ index
+ });
+ }
+ options.api.push({
+ importName,
+ layer,
+ supports,
+ media,
+ index
+ });
+ }
+ }
+ };
+ }
+ };
+};
+plugin.postcss = true;
+var _default = exports.default = plugin;
Index: frontend/node_modules/css-loader/dist/plugins/postcss-url-parser.js
===================================================================
--- frontend/node_modules/css-loader/dist/plugins/postcss-url-parser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/plugins/postcss-url-parser.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,356 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const isUrlFunc = /url/i;
+const isImageSetFunc = /^(?:-webkit-)?image-set$/i;
+const needParseDeclaration = /(?:url|(?:-webkit-)?image-set)\(/i;
+function getNodeFromUrlFunc(node) {
+ return node.nodes && node.nodes[0];
+}
+function getWebpackIgnoreCommentValue(index, nodes, inBetween) {
+ if (index === 0 && typeof inBetween !== "undefined") {
+ return inBetween;
+ }
+ let prevValueNode = nodes[index - 1];
+ if (!prevValueNode) {
+ // eslint-disable-next-line consistent-return
+ return;
+ }
+ if (prevValueNode.type === "space") {
+ if (!nodes[index - 2]) {
+ // eslint-disable-next-line consistent-return
+ return;
+ }
+ prevValueNode = nodes[index - 2];
+ }
+ if (prevValueNode.type !== "comment") {
+ // eslint-disable-next-line consistent-return
+ return;
+ }
+ const matched = prevValueNode.value.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+ return matched && matched[2] === "true";
+}
+function shouldHandleURL(url, declaration, result, options) {
+ if (url.length === 0) {
+ result.warn(`Unable to find uri in '${declaration.toString()}'`, {
+ node: declaration
+ });
+ return {
+ requestable: false,
+ needResolve: false
+ };
+ }
+ return (0, _utils.isURLRequestable)(url, options);
+}
+function parseDeclaration(declaration, key, result, options) {
+ if (!needParseDeclaration.test(declaration[key])) {
+ return;
+ }
+ const parsed = (0, _postcssValueParser.default)(declaration.raws && declaration.raws.value && declaration.raws.value.raw ? declaration.raws.value.raw : declaration[key]);
+ let inBetween;
+ if (declaration.raws && declaration.raws.between) {
+ const lastCommentIndex = declaration.raws.between.lastIndexOf("/*");
+ const matched = declaration.raws.between.slice(lastCommentIndex).match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+ if (matched) {
+ inBetween = matched[2] === "true";
+ }
+ }
+ let isIgnoreOnDeclaration = false;
+ const prevNode = declaration.prev();
+ if (prevNode && prevNode.type === "comment") {
+ const matched = prevNode.text.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+ if (matched) {
+ isIgnoreOnDeclaration = matched[2] === "true";
+ }
+ }
+ let needIgnore;
+ const parsedURLs = [];
+ parsed.walk((valueNode, index, valueNodes) => {
+ if (valueNode.type !== "function") {
+ return;
+ }
+ if (isUrlFunc.test(valueNode.value)) {
+ needIgnore = getWebpackIgnoreCommentValue(index, valueNodes, inBetween);
+ if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+ if (needIgnore) {
+ // eslint-disable-next-line no-undefined
+ needIgnore = undefined;
+ }
+ return;
+ }
+ const {
+ nodes
+ } = valueNode;
+ const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
+ let url = isStringValue ? nodes[0].value : _postcssValueParser.default.stringify(nodes);
+ url = (0, _utils.normalizeUrl)(url, isStringValue);
+ const {
+ requestable,
+ needResolve
+ } = shouldHandleURL(url, declaration, result, options);
+
+ // Do not traverse inside `url`
+ if (!requestable) {
+ // eslint-disable-next-line consistent-return
+ return false;
+ }
+ const queryParts = url.split("!");
+ let prefix;
+ if (queryParts.length > 1) {
+ url = queryParts.pop();
+ prefix = queryParts.join("!");
+ }
+ parsedURLs.push({
+ declaration,
+ parsed,
+ node: getNodeFromUrlFunc(valueNode),
+ prefix,
+ url,
+ needQuotes: false,
+ needResolve
+ });
+
+ // eslint-disable-next-line consistent-return
+ return false;
+ } else if (isImageSetFunc.test(valueNode.value)) {
+ for (const [innerIndex, nNode] of valueNode.nodes.entries()) {
+ const {
+ type,
+ value
+ } = nNode;
+ if (type === "function" && isUrlFunc.test(value)) {
+ needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
+ if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+ if (needIgnore) {
+ // eslint-disable-next-line no-undefined
+ needIgnore = undefined;
+ }
+
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+ const {
+ nodes
+ } = nNode;
+ const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
+ let url = isStringValue ? nodes[0].value : _postcssValueParser.default.stringify(nodes);
+ url = (0, _utils.normalizeUrl)(url, isStringValue);
+ const {
+ requestable,
+ needResolve
+ } = shouldHandleURL(url, declaration, result, options);
+
+ // Do not traverse inside `url`
+ if (!requestable) {
+ // eslint-disable-next-line consistent-return
+ return false;
+ }
+ const queryParts = url.split("!");
+ let prefix;
+ if (queryParts.length > 1) {
+ url = queryParts.pop();
+ prefix = queryParts.join("!");
+ }
+ parsedURLs.push({
+ declaration,
+ parsed,
+ node: getNodeFromUrlFunc(nNode),
+ prefix,
+ url,
+ needQuotes: false,
+ needResolve
+ });
+ } else if (type === "string") {
+ needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
+ if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+ if (needIgnore) {
+ // eslint-disable-next-line no-undefined
+ needIgnore = undefined;
+ }
+
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+ let url = (0, _utils.normalizeUrl)(value, true);
+ const {
+ requestable,
+ needResolve
+ } = shouldHandleURL(url, declaration, result, options);
+
+ // Do not traverse inside `url`
+ if (!requestable) {
+ // eslint-disable-next-line consistent-return
+ return false;
+ }
+ const queryParts = url.split("!");
+ let prefix;
+ if (queryParts.length > 1) {
+ url = queryParts.pop();
+ prefix = queryParts.join("!");
+ }
+ parsedURLs.push({
+ declaration,
+ parsed,
+ node: nNode,
+ prefix,
+ url,
+ needQuotes: true,
+ needResolve
+ });
+ }
+ }
+
+ // Do not traverse inside `image-set`
+ // eslint-disable-next-line consistent-return
+ return false;
+ }
+ });
+
+ // eslint-disable-next-line consistent-return
+ return parsedURLs;
+}
+const plugin = (options = {}) => {
+ return {
+ postcssPlugin: "postcss-url-parser",
+ prepare(result) {
+ const parsedDeclarations = [];
+ return {
+ Declaration(declaration) {
+ const {
+ isSupportDataURL,
+ isSupportAbsoluteURL
+ } = options;
+ const parsedURL = parseDeclaration(declaration, "value", result, {
+ isSupportDataURL,
+ isSupportAbsoluteURL
+ });
+ if (!parsedURL) {
+ return;
+ }
+ parsedDeclarations.push(...parsedURL);
+ },
+ async OnceExit() {
+ if (parsedDeclarations.length === 0) {
+ return;
+ }
+ const resolvedDeclarations = await Promise.all(parsedDeclarations.map(async parsedDeclaration => {
+ const {
+ url,
+ needResolve
+ } = parsedDeclaration;
+ if (options.filter) {
+ const needKeep = await options.filter(url);
+ if (!needKeep) {
+ // eslint-disable-next-line consistent-return
+ return;
+ }
+ }
+ if (!needResolve) {
+ // eslint-disable-next-line consistent-return
+ return parsedDeclaration;
+ }
+ const splittedUrl = url.split(/(\?)?#/);
+ const [pathname, query, hashOrQuery] = splittedUrl;
+ let hash = query ? "?" : "";
+ hash += hashOrQuery ? `#${hashOrQuery}` : "";
+ const {
+ resolver,
+ rootContext
+ } = options;
+ const request = (0, _utils.requestify)(pathname, rootContext, Boolean(resolver));
+ if (!resolver) {
+ // eslint-disable-next-line consistent-return
+ return {
+ ...parsedDeclaration,
+ url: request,
+ hash
+ };
+ }
+ const resolvedURL = await (0, _utils.resolveRequests)(resolver, options.context, [...new Set([request, url])]);
+ if (!resolvedURL) {
+ // eslint-disable-next-line consistent-return
+ return;
+ }
+
+ // eslint-disable-next-line consistent-return
+ return {
+ ...parsedDeclaration,
+ url: resolvedURL,
+ hash
+ };
+ }));
+ const urlToNameMap = new Map();
+ const urlToReplacementMap = new Map();
+ let hasUrlImportHelper = false;
+ for (let index = 0; index <= resolvedDeclarations.length - 1; index++) {
+ const item = resolvedDeclarations[index];
+ if (!item) {
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+ if (!hasUrlImportHelper) {
+ options.imports.push({
+ type: "get_url_import",
+ importName: "___CSS_LOADER_GET_URL_IMPORT___",
+ url: options.urlHandler(require.resolve("../runtime/getUrl.js")),
+ index: -1
+ });
+ hasUrlImportHelper = true;
+ }
+ const {
+ url,
+ prefix
+ } = item;
+ const newUrl = prefix ? `${prefix}!${url}` : url;
+ let importName = urlToNameMap.get(newUrl);
+ if (!importName) {
+ importName = `___CSS_LOADER_URL_IMPORT_${urlToNameMap.size}___`;
+ urlToNameMap.set(newUrl, importName);
+ options.imports.push({
+ type: "url",
+ importName,
+ url: options.resolver ? options.urlHandler(newUrl) : JSON.stringify(newUrl),
+ index
+ });
+ }
+ const {
+ hash,
+ needQuotes
+ } = item;
+ const replacementKey = JSON.stringify({
+ newUrl,
+ hash,
+ needQuotes
+ });
+ let replacementName = urlToReplacementMap.get(replacementKey);
+ if (!replacementName) {
+ replacementName = `___CSS_LOADER_URL_REPLACEMENT_${urlToReplacementMap.size}___`;
+ urlToReplacementMap.set(replacementKey, replacementName);
+ options.replacements.push({
+ replacementName,
+ importName,
+ hash,
+ needQuotes
+ });
+ }
+
+ // eslint-disable-next-line no-param-reassign
+ item.node.type = "word";
+ // eslint-disable-next-line no-param-reassign
+ item.node.value = replacementName;
+ // eslint-disable-next-line no-param-reassign
+ item.declaration.value = item.parsed.toString();
+ }
+ }
+ };
+ }
+ };
+};
+plugin.postcss = true;
+var _default = exports.default = plugin;
Index: frontend/node_modules/css-loader/dist/runtime/api.js
===================================================================
--- frontend/node_modules/css-loader/dist/runtime/api.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/runtime/api.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,85 @@
+"use strict";
+
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+module.exports = function (cssWithMappingToString) {
+ var list = [];
+
+ // return the list of modules as css string
+ list.toString = function toString() {
+ return this.map(function (item) {
+ var content = "";
+ var needLayer = typeof item[5] !== "undefined";
+ if (item[4]) {
+ content += "@supports (".concat(item[4], ") {");
+ }
+ if (item[2]) {
+ content += "@media ".concat(item[2], " {");
+ }
+ if (needLayer) {
+ content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
+ }
+ content += cssWithMappingToString(item);
+ if (needLayer) {
+ content += "}";
+ }
+ if (item[2]) {
+ content += "}";
+ }
+ if (item[4]) {
+ content += "}";
+ }
+ return content;
+ }).join("");
+ };
+
+ // import a list of modules into the list
+ list.i = function i(modules, media, dedupe, supports, layer) {
+ if (typeof modules === "string") {
+ modules = [[null, modules, undefined]];
+ }
+ var alreadyImportedModules = {};
+ if (dedupe) {
+ for (var k = 0; k < this.length; k++) {
+ var id = this[k][0];
+ if (id != null) {
+ alreadyImportedModules[id] = true;
+ }
+ }
+ }
+ for (var _k = 0; _k < modules.length; _k++) {
+ var item = [].concat(modules[_k]);
+ if (dedupe && alreadyImportedModules[item[0]]) {
+ continue;
+ }
+ if (typeof layer !== "undefined") {
+ if (typeof item[5] === "undefined") {
+ item[5] = layer;
+ } else {
+ item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
+ item[5] = layer;
+ }
+ }
+ if (media) {
+ if (!item[2]) {
+ item[2] = media;
+ } else {
+ item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
+ item[2] = media;
+ }
+ }
+ if (supports) {
+ if (!item[4]) {
+ item[4] = "".concat(supports);
+ } else {
+ item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
+ item[4] = supports;
+ }
+ }
+ list.push(item);
+ }
+ };
+ return list;
+};
Index: frontend/node_modules/css-loader/dist/runtime/getUrl.js
===================================================================
--- frontend/node_modules/css-loader/dist/runtime/getUrl.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/runtime/getUrl.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,26 @@
+"use strict";
+
+module.exports = function (url, options) {
+ if (!options) {
+ options = {};
+ }
+ if (!url) {
+ return url;
+ }
+ url = String(url.__esModule ? url.default : url);
+
+ // If url is already wrapped in quotes, remove them
+ if (/^['"].*['"]$/.test(url)) {
+ url = url.slice(1, -1);
+ }
+ if (options.hash) {
+ url += options.hash;
+ }
+
+ // Should url be wrapped?
+ // See https://drafts.csswg.org/css-values-3/#urls
+ if (/["'() \t\n]|(%20)/.test(url) || options.needQuotes) {
+ return "\"".concat(url.replace(/"/g, '\\"').replace(/\n/g, "\\n"), "\"");
+ }
+ return url;
+};
Index: frontend/node_modules/css-loader/dist/runtime/noSourceMaps.js
===================================================================
--- frontend/node_modules/css-loader/dist/runtime/noSourceMaps.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/runtime/noSourceMaps.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (i) {
+ return i[1];
+};
Index: frontend/node_modules/css-loader/dist/runtime/sourceMaps.js
===================================================================
--- frontend/node_modules/css-loader/dist/runtime/sourceMaps.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/runtime/sourceMaps.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,16 @@
+"use strict";
+
+module.exports = function (item) {
+ var content = item[1];
+ var cssMapping = item[3];
+ if (!cssMapping) {
+ return content;
+ }
+ if (typeof btoa === "function") {
+ var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+ var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+ var sourceMapping = "/*# ".concat(data, " */");
+ return [content].concat([sourceMapping]).join("\n");
+ }
+ return [content].join("\n");
+};
Index: frontend/node_modules/css-loader/dist/utils.js
===================================================================
--- frontend/node_modules/css-loader/dist/utils.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/dist/utils.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1064 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.WEBPACK_IGNORE_COMMENT_REGEXP = void 0;
+exports.camelCase = camelCase;
+exports.combineRequests = combineRequests;
+exports.defaultGetLocalIdent = defaultGetLocalIdent;
+exports.getExportCode = getExportCode;
+exports.getFilter = getFilter;
+exports.getImportCode = getImportCode;
+exports.getModuleCode = getModuleCode;
+exports.getModulesOptions = getModulesOptions;
+exports.getModulesPlugins = getModulesPlugins;
+exports.getPreRequester = getPreRequester;
+exports.isDataUrl = isDataUrl;
+exports.isURLRequestable = isURLRequestable;
+exports.normalizeOptions = normalizeOptions;
+exports.normalizeSourceMap = normalizeSourceMap;
+exports.normalizeUrl = normalizeUrl;
+exports.requestify = requestify;
+exports.resolveRequests = resolveRequests;
+exports.shouldUseIcssPlugin = shouldUseIcssPlugin;
+exports.shouldUseImportPlugin = shouldUseImportPlugin;
+exports.shouldUseModulesPlugins = shouldUseModulesPlugins;
+exports.shouldUseURLPlugin = shouldUseURLPlugin;
+exports.sort = sort;
+exports.stringifyRequest = stringifyRequest;
+exports.syntaxErrorFactory = syntaxErrorFactory;
+exports.warningFactory = warningFactory;
+var _url = require("url");
+var _path = _interopRequireDefault(require("path"));
+var _postcssModulesValues = _interopRequireDefault(require("postcss-modules-values"));
+var _postcssModulesLocalByDefault = _interopRequireDefault(require("postcss-modules-local-by-default"));
+var _postcssModulesExtractImports = _interopRequireDefault(require("postcss-modules-extract-imports"));
+var _postcssModulesScope = _interopRequireDefault(require("postcss-modules-scope"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+const WEBPACK_IGNORE_COMMENT_REGEXP = exports.WEBPACK_IGNORE_COMMENT_REGEXP = /webpackIgnore:(\s+)?(true|false)/;
+const matchRelativePath = /^\.\.?[/\\]/;
+function isAbsolutePath(str) {
+ return _path.default.posix.isAbsolute(str) || _path.default.win32.isAbsolute(str);
+}
+function isRelativePath(str) {
+ return matchRelativePath.test(str);
+}
+
+// TODO simplify for the next major release
+function stringifyRequest(loaderContext, request) {
+ if (typeof loaderContext.utils !== "undefined" && typeof loaderContext.utils.contextify === "function") {
+ return JSON.stringify(loaderContext.utils.contextify(loaderContext.context || loaderContext.rootContext, request));
+ }
+ const splitted = request.split("!");
+ const {
+ context
+ } = loaderContext;
+ return JSON.stringify(splitted.map(part => {
+ // First, separate singlePath from query, because the query might contain paths again
+ const splittedPart = part.match(/^(.*?)(\?.*)/);
+ const query = splittedPart ? splittedPart[2] : "";
+ let singlePath = splittedPart ? splittedPart[1] : part;
+ if (isAbsolutePath(singlePath) && context) {
+ singlePath = _path.default.relative(context, singlePath);
+ if (isAbsolutePath(singlePath)) {
+ // If singlePath still matches an absolute path, singlePath was on a different drive than context.
+ // In this case, we leave the path platform-specific without replacing any separators.
+ // @see https://github.com/webpack/loader-utils/pull/14
+ return singlePath + query;
+ }
+ if (isRelativePath(singlePath) === false) {
+ // Ensure that the relative path starts at least with ./ otherwise it would be a request into the modules directory (like node_modules).
+ singlePath = `./${singlePath}`;
+ }
+ }
+ return singlePath.replace(/\\/g, "/") + query;
+ }).join("!"));
+}
+
+// We can't use path.win32.isAbsolute because it also matches paths starting with a forward slash
+const IS_NATIVE_WIN32_PATH = /^[a-z]:[/\\]|^\\\\/i;
+const IS_MODULE_REQUEST = /^[^?]*~/;
+function urlToRequest(url, root) {
+ let request;
+ if (IS_NATIVE_WIN32_PATH.test(url)) {
+ // absolute windows path, keep it
+ request = url;
+ } else if (typeof root !== "undefined" && /^\//.test(url)) {
+ request = root + url;
+ } else if (/^\.\.?\//.test(url)) {
+ // A relative url stays
+ request = url;
+ } else {
+ // every other url is threaded like a relative url
+ request = `./${url}`;
+ }
+
+ // A `~` makes the url an module
+ if (IS_MODULE_REQUEST.test(request)) {
+ request = request.replace(IS_MODULE_REQUEST, "");
+ }
+ return request;
+}
+
+// eslint-disable-next-line no-useless-escape
+const regexSingleEscape = /[ -,.\/:-@[\]\^`{-~]/;
+const regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
+const preserveCamelCase = string => {
+ let result = string;
+ let isLastCharLower = false;
+ let isLastCharUpper = false;
+ let isLastLastCharUpper = false;
+ for (let i = 0; i < result.length; i++) {
+ const character = result[i];
+ if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+ result = `${result.slice(0, i)}-${result.slice(i)}`;
+ isLastCharLower = false;
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = true;
+ i += 1;
+ } else if (isLastCharUpper && isLastLastCharUpper && /[\p{Ll}]/u.test(character)) {
+ result = `${result.slice(0, i - 1)}-${result.slice(i - 1)}`;
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = false;
+ isLastCharLower = true;
+ } else {
+ isLastCharLower = character.toLowerCase() === character && character.toUpperCase() !== character;
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = character.toUpperCase() === character && character.toLowerCase() !== character;
+ }
+ }
+ return result;
+};
+function camelCase(input) {
+ let result = input.trim();
+ if (result.length === 0) {
+ return "";
+ }
+ if (result.length === 1) {
+ return result.toLowerCase();
+ }
+ const hasUpperCase = result !== result.toLowerCase();
+ if (hasUpperCase) {
+ result = preserveCamelCase(result);
+ }
+ return result.replace(/^[_.\- ]+/, "").toLowerCase().replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toUpperCase()).replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toUpperCase());
+}
+function escape(string) {
+ let output = "";
+ let counter = 0;
+ while (counter < string.length) {
+ // eslint-disable-next-line no-plusplus
+ const character = string.charAt(counter++);
+ let value;
+
+ // eslint-disable-next-line no-control-regex
+ if (/[\t\n\f\r\x0B]/.test(character)) {
+ const codePoint = character.charCodeAt();
+ value = `\\${codePoint.toString(16).toUpperCase()} `;
+ } else if (character === "\\" || regexSingleEscape.test(character)) {
+ value = `\\${character}`;
+ } else {
+ value = character;
+ }
+ output += value;
+ }
+ const firstChar = string.charAt(0);
+ if (/^-[-\d]/.test(output)) {
+ output = `\\-${output.slice(1)}`;
+ } else if (/\d/.test(firstChar)) {
+ output = `\\3${firstChar} ${output.slice(1)}`;
+ }
+
+ // Remove spaces after `\HEX` escapes that are not followed by a hex digit,
+ // since they’re redundant. Note that this is only possible if the escape
+ // sequence isn’t preceded by an odd number of backslashes.
+ output = output.replace(regexExcessiveSpaces, ($0, $1, $2) => {
+ if ($1 && $1.length % 2) {
+ // It’s not safe to remove the space, so don’t.
+ return $0;
+ }
+
+ // Strip the space.
+ return ($1 || "") + $2;
+ });
+ return output;
+}
+function gobbleHex(str) {
+ const lower = str.toLowerCase();
+ let hex = "";
+ let spaceTerminated = false;
+
+ // eslint-disable-next-line no-undefined
+ for (let i = 0; i < 6 && lower[i] !== undefined; i++) {
+ const code = lower.charCodeAt(i);
+ // check to see if we are dealing with a valid hex char [a-f|0-9]
+ const valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
+ // https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
+ spaceTerminated = code === 32;
+ if (!valid) {
+ break;
+ }
+ hex += lower[i];
+ }
+ if (hex.length === 0) {
+ // eslint-disable-next-line no-undefined
+ return undefined;
+ }
+ const codePoint = parseInt(hex, 16);
+ const isSurrogate = codePoint >= 0xd800 && codePoint <= 0xdfff;
+ // Add special case for
+ // "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
+ // https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
+ if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10ffff) {
+ return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
+ }
+ return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
+}
+const CONTAINS_ESCAPE = /\\/;
+function unescape(str) {
+ const needToProcess = CONTAINS_ESCAPE.test(str);
+ if (!needToProcess) {
+ return str;
+ }
+ let ret = "";
+ for (let i = 0; i < str.length; i++) {
+ if (str[i] === "\\") {
+ const gobbled = gobbleHex(str.slice(i + 1, i + 7));
+
+ // eslint-disable-next-line no-undefined
+ if (gobbled !== undefined) {
+ ret += gobbled[0];
+ i += gobbled[1];
+
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+
+ // Retain a pair of \\ if double escaped `\\\\`
+ // https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
+ if (str[i + 1] === "\\") {
+ ret += "\\";
+ i += 1;
+
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+
+ // if \\ is at the end of the string retain it
+ // https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
+ if (str.length === i + 1) {
+ ret += str[i];
+ }
+
+ // eslint-disable-next-line no-continue
+ continue;
+ }
+ ret += str[i];
+ }
+ return ret;
+}
+function normalizePath(file) {
+ return _path.default.sep === "\\" ? file.replace(/\\/g, "/") : file;
+}
+
+// eslint-disable-next-line no-control-regex
+const filenameReservedRegex = /[<>:"/\\|?*]/g;
+// eslint-disable-next-line no-control-regex
+const reControlChars = /[\u0000-\u001f\u0080-\u009f]/g;
+function escapeLocalIdent(localident) {
+ // TODO simplify in the next major release
+ return escape(localident
+ // For `[hash]` placeholder
+ .replace(/^((-?[0-9])|--)/, "_$1").replace(filenameReservedRegex, "-").replace(reControlChars, "-").replace(/\./g, "-"));
+}
+function defaultGetLocalIdent(loaderContext, localIdentName, localName, options) {
+ const {
+ context,
+ hashSalt,
+ hashStrategy
+ } = options;
+ const {
+ resourcePath
+ } = loaderContext;
+ let relativeResourcePath = normalizePath(_path.default.relative(context, resourcePath));
+
+ // eslint-disable-next-line no-underscore-dangle
+ if (loaderContext._module && loaderContext._module.matchResource) {
+ relativeResourcePath = `${normalizePath(
+ // eslint-disable-next-line no-underscore-dangle
+ _path.default.relative(context, loaderContext._module.matchResource))}`;
+ }
+
+ // eslint-disable-next-line no-param-reassign
+ options.content = hashStrategy === "minimal-subset" && /\[local\]/.test(localIdentName) ? relativeResourcePath : `${relativeResourcePath}\x00${localName}`;
+ let {
+ hashFunction,
+ hashDigest,
+ hashDigestLength
+ } = options;
+ const matches = localIdentName.match(/\[(?:([^:\]]+):)?(?:(hash|contenthash|fullhash))(?::([a-z]+\d*))?(?::(\d+))?\]/i);
+ if (matches) {
+ const hashName = matches[2] || hashFunction;
+ hashFunction = matches[1] || hashFunction;
+ hashDigest = matches[3] || hashDigest;
+ hashDigestLength = matches[4] || hashDigestLength;
+
+ // `hash` and `contenthash` are same in `loader-utils` context
+ // let's keep `hash` for backward compatibility
+
+ // eslint-disable-next-line no-param-reassign
+ localIdentName = localIdentName.replace(/\[(?:([^:\]]+):)?(?:hash|contenthash|fullhash)(?::([a-z]+\d*))?(?::(\d+))?\]/gi, () => hashName === "fullhash" ? "[fullhash]" : "[contenthash]");
+ }
+ let localIdentHash = "";
+ for (let tier = 0; localIdentHash.length < hashDigestLength; tier++) {
+ // TODO remove this in the next major release
+ const hash = loaderContext.utils && typeof loaderContext.utils.createHash === "function" ? loaderContext.utils.createHash(hashFunction) :
+ // eslint-disable-next-line no-underscore-dangle
+ loaderContext._compiler.webpack.util.createHash(hashFunction);
+ if (hashSalt) {
+ hash.update(hashSalt);
+ }
+ const tierSalt = Buffer.allocUnsafe(4);
+ tierSalt.writeUInt32LE(tier);
+ hash.update(tierSalt);
+ // TODO: bug in webpack with unicode characters with strings
+ hash.update(Buffer.from(options.content, "utf8"));
+ localIdentHash = (localIdentHash + hash.digest(hashDigest)
+ // Remove all leading digits
+ ).replace(/^\d+/, "")
+ // Replace all slashes with underscores (same as in base64url)
+ .replace(/\//g, "_")
+ // Remove everything that is not an alphanumeric or underscore
+ .replace(/[^A-Za-z0-9_]+/g, "").slice(0, hashDigestLength);
+ }
+
+ // TODO need improve on webpack side, we should allow to pass hash/contentHash without chunk property, also `data` for `getPath` should be looks good without chunk property
+ const ext = _path.default.extname(resourcePath);
+ const base = _path.default.basename(resourcePath);
+ const name = base.slice(0, base.length - ext.length);
+ const data = {
+ filename: _path.default.relative(context, resourcePath),
+ contentHash: localIdentHash,
+ chunk: {
+ name,
+ hash: localIdentHash,
+ contentHash: localIdentHash
+ }
+ };
+
+ // eslint-disable-next-line no-underscore-dangle
+ let result = loaderContext._compilation.getPath(localIdentName, data);
+ if (/\[folder\]/gi.test(result)) {
+ const dirname = _path.default.dirname(resourcePath);
+ let directory = normalizePath(_path.default.relative(context, `${dirname + _path.default.sep}_`));
+ directory = directory.substring(0, directory.length - 1);
+ let folder = "";
+ if (directory.length > 1) {
+ folder = _path.default.basename(directory);
+ }
+ result = result.replace(/\[folder\]/gi, () => folder);
+ }
+ if (options.regExp) {
+ const match = resourcePath.match(options.regExp);
+ if (match) {
+ match.forEach((matched, i) => {
+ result = result.replace(new RegExp(`\\[${i}\\]`, "ig"), matched);
+ });
+ }
+ }
+ return result;
+}
+function fixedEncodeURIComponent(str) {
+ return str.replace(/[!'()*]/g, c => `%${c.charCodeAt(0).toString(16)}`);
+}
+function isDataUrl(url) {
+ if (/^data:/i.test(url)) {
+ return true;
+ }
+ return false;
+}
+const NATIVE_WIN32_PATH = /^[A-Z]:[/\\]|^\\\\/i;
+function normalizeUrl(url, isStringValue) {
+ let normalizedUrl = url.replace(/^( |\t\n|\r\n|\r|\f)*/g, "").replace(/( |\t\n|\r\n|\r|\f)*$/g, "");
+ if (isStringValue && /\\(\n|\r\n|\r|\f)/.test(normalizedUrl)) {
+ normalizedUrl = normalizedUrl.replace(/\\(\n|\r\n|\r|\f)/g, "");
+ }
+ if (NATIVE_WIN32_PATH.test(url)) {
+ try {
+ normalizedUrl = decodeURI(normalizedUrl);
+ } catch (error) {
+ // Ignore
+ }
+ return normalizedUrl;
+ }
+ normalizedUrl = unescape(normalizedUrl);
+ if (isDataUrl(url)) {
+ // Todo fixedEncodeURIComponent is workaround. Webpack resolver shouldn't handle "!" in dataURL
+ return fixedEncodeURIComponent(normalizedUrl);
+ }
+ try {
+ normalizedUrl = decodeURI(normalizedUrl);
+ } catch (error) {
+ // Ignore
+ }
+ return normalizedUrl;
+}
+function requestify(url, rootContext, needToResolveURL = true) {
+ if (needToResolveURL) {
+ if (/^file:/i.test(url)) {
+ return (0, _url.fileURLToPath)(url);
+ }
+ return url.charAt(0) === "/" ? urlToRequest(url, rootContext) : urlToRequest(url);
+ }
+ if (url.charAt(0) === "/" || /^file:/i.test(url)) {
+ return url;
+ }
+
+ // A `~` makes the url an module
+ if (IS_MODULE_REQUEST.test(url)) {
+ return url.replace(IS_MODULE_REQUEST, "");
+ }
+ return url;
+}
+function getFilter(filter, resourcePath) {
+ return (...args) => {
+ if (typeof filter === "function") {
+ return filter(...args, resourcePath);
+ }
+ return true;
+ };
+}
+function getValidLocalName(localName, exportLocalsConvention) {
+ const result = exportLocalsConvention(localName);
+ return Array.isArray(result) ? result[0] : result;
+}
+const IS_MODULES = /\.module(s)?\.\w+$/i;
+const IS_ICSS = /\.icss\.\w+$/i;
+function getModulesOptions(rawOptions, exportType, loaderContext) {
+ if (typeof rawOptions.modules === "boolean" && rawOptions.modules === false) {
+ return false;
+ }
+ const resourcePath =
+ // eslint-disable-next-line no-underscore-dangle
+ loaderContext._module && loaderContext._module.matchResource || loaderContext.resourcePath;
+ let auto;
+ let rawModulesOptions;
+ if (typeof rawOptions.modules === "undefined") {
+ rawModulesOptions = {};
+ auto = true;
+ } else if (typeof rawOptions.modules === "boolean") {
+ rawModulesOptions = {};
+ } else if (typeof rawOptions.modules === "string") {
+ rawModulesOptions = {
+ mode: rawOptions.modules
+ };
+ } else {
+ rawModulesOptions = rawOptions.modules;
+ ({
+ auto
+ } = rawModulesOptions);
+ }
+
+ // eslint-disable-next-line no-underscore-dangle
+ const {
+ outputOptions
+ } = loaderContext._compilation;
+ const needNamedExport = exportType === "css-style-sheet" || exportType === "string";
+ const modulesOptions = {
+ auto,
+ mode: "local",
+ exportGlobals: false,
+ localIdentName: "[hash:base64]",
+ localIdentContext: loaderContext.rootContext,
+ localIdentHashSalt: outputOptions.hashSalt,
+ localIdentHashFunction: outputOptions.hashFunction,
+ localIdentHashDigest: outputOptions.hashDigest,
+ localIdentHashDigestLength: outputOptions.hashDigestLength,
+ // eslint-disable-next-line no-undefined
+ localIdentRegExp: undefined,
+ // eslint-disable-next-line no-undefined
+ getLocalIdent: undefined,
+ namedExport: needNamedExport || false,
+ exportLocalsConvention: (rawModulesOptions.namedExport === true || needNamedExport) && typeof rawModulesOptions.exportLocalsConvention === "undefined" ? "camelCaseOnly" : "asIs",
+ exportOnlyLocals: false,
+ ...rawModulesOptions,
+ useExportsAs: rawModulesOptions.exportLocalsConvention === "asIs"
+ };
+ let exportLocalsConventionType;
+ if (typeof modulesOptions.exportLocalsConvention === "string") {
+ exportLocalsConventionType = modulesOptions.exportLocalsConvention;
+ modulesOptions.exportLocalsConvention = name => {
+ switch (exportLocalsConventionType) {
+ case "camelCase":
+ {
+ return [name, camelCase(name)];
+ }
+ case "camelCaseOnly":
+ {
+ return camelCase(name);
+ }
+ case "dashes":
+ {
+ return [name, dashesCamelCase(name)];
+ }
+ case "dashesOnly":
+ {
+ return dashesCamelCase(name);
+ }
+ case "asIs":
+ default:
+ return name;
+ }
+ };
+ }
+ if (typeof modulesOptions.auto === "boolean") {
+ const isModules = modulesOptions.auto && IS_MODULES.test(resourcePath);
+ let isIcss;
+ if (!isModules) {
+ isIcss = IS_ICSS.test(resourcePath);
+ if (isIcss) {
+ modulesOptions.mode = "icss";
+ }
+ }
+ if (!isModules && !isIcss) {
+ return false;
+ }
+ } else if (modulesOptions.auto instanceof RegExp) {
+ const isModules = modulesOptions.auto.test(resourcePath);
+ if (!isModules) {
+ return false;
+ }
+ } else if (typeof modulesOptions.auto === "function") {
+ const {
+ resourceQuery,
+ resourceFragment
+ } = loaderContext;
+ const isModule = modulesOptions.auto(resourcePath, resourceQuery, resourceFragment);
+ if (!isModule) {
+ return false;
+ }
+ }
+ if (typeof modulesOptions.mode === "function") {
+ modulesOptions.mode = modulesOptions.mode(loaderContext.resourcePath, loaderContext.resourceQuery, loaderContext.resourceFragment);
+ }
+ if (needNamedExport) {
+ if (rawOptions.esModule === false) {
+ throw new Error("The 'exportType' option with the 'css-style-sheet' or 'string' value requires the 'esModule' option to be enabled");
+ }
+ if (modulesOptions.namedExport === false) {
+ throw new Error("The 'exportType' option with the 'css-style-sheet' or 'string' value requires the 'modules.namedExport' option to be enabled");
+ }
+ }
+ if (modulesOptions.namedExport === true) {
+ if (rawOptions.esModule === false) {
+ throw new Error("The 'modules.namedExport' option requires the 'esModule' option to be enabled");
+ }
+ if (typeof exportLocalsConventionType === "string" && exportLocalsConventionType !== "asIs" && exportLocalsConventionType !== "camelCaseOnly" && exportLocalsConventionType !== "dashesOnly") {
+ throw new Error('The "modules.namedExport" option requires the "modules.exportLocalsConvention" option to be "camelCaseOnly" or "dashesOnly"');
+ }
+ }
+ return modulesOptions;
+}
+function normalizeOptions(rawOptions, loaderContext) {
+ const exportType = typeof rawOptions.exportType === "undefined" ? "array" : rawOptions.exportType;
+ const modulesOptions = getModulesOptions(rawOptions, exportType, loaderContext);
+ return {
+ url: typeof rawOptions.url === "undefined" ? true : rawOptions.url,
+ import: typeof rawOptions.import === "undefined" ? true : rawOptions.import,
+ modules: modulesOptions,
+ sourceMap: typeof rawOptions.sourceMap === "boolean" ? rawOptions.sourceMap : loaderContext.sourceMap,
+ importLoaders: typeof rawOptions.importLoaders === "string" ? parseInt(rawOptions.importLoaders, 10) : rawOptions.importLoaders,
+ esModule: typeof rawOptions.esModule === "undefined" ? true : rawOptions.esModule,
+ exportType
+ };
+}
+function shouldUseImportPlugin(options) {
+ if (options.modules.exportOnlyLocals) {
+ return false;
+ }
+ if (typeof options.import === "boolean") {
+ return options.import;
+ }
+ return true;
+}
+function shouldUseURLPlugin(options) {
+ if (options.modules.exportOnlyLocals) {
+ return false;
+ }
+ if (typeof options.url === "boolean") {
+ return options.url;
+ }
+ return true;
+}
+function shouldUseModulesPlugins(options) {
+ if (typeof options.modules === "boolean" && options.modules === false) {
+ return false;
+ }
+ return options.modules.mode !== "icss";
+}
+function shouldUseIcssPlugin(options) {
+ return Boolean(options.modules);
+}
+function getModulesPlugins(options, loaderContext) {
+ const {
+ mode,
+ getLocalIdent,
+ localIdentName,
+ localIdentContext,
+ localIdentHashSalt,
+ localIdentHashFunction,
+ localIdentHashDigest,
+ localIdentHashDigestLength,
+ localIdentRegExp,
+ hashStrategy
+ } = options.modules;
+ let plugins = [];
+ try {
+ plugins = [_postcssModulesValues.default, (0, _postcssModulesLocalByDefault.default)({
+ mode
+ }), (0, _postcssModulesExtractImports.default)(), (0, _postcssModulesScope.default)({
+ generateScopedName(exportName, resourceFile, rawCss, node) {
+ let localIdent;
+ if (typeof getLocalIdent !== "undefined") {
+ localIdent = getLocalIdent(loaderContext, localIdentName, unescape(exportName), {
+ context: localIdentContext,
+ hashSalt: localIdentHashSalt,
+ hashFunction: localIdentHashFunction,
+ hashDigest: localIdentHashDigest,
+ hashDigestLength: localIdentHashDigestLength,
+ hashStrategy,
+ regExp: localIdentRegExp,
+ node
+ });
+ }
+
+ // A null/undefined value signals that we should invoke the default
+ // getLocalIdent method.
+ if (typeof localIdent === "undefined" || localIdent === null) {
+ localIdent = defaultGetLocalIdent(loaderContext, localIdentName, unescape(exportName), {
+ context: localIdentContext,
+ hashSalt: localIdentHashSalt,
+ hashFunction: localIdentHashFunction,
+ hashDigest: localIdentHashDigest,
+ hashDigestLength: localIdentHashDigestLength,
+ hashStrategy,
+ regExp: localIdentRegExp,
+ node
+ });
+ return escapeLocalIdent(localIdent).replace(/\\\[local\\]/gi, exportName);
+ }
+ return escapeLocalIdent(localIdent);
+ },
+ exportGlobals: options.modules.exportGlobals
+ })];
+ } catch (error) {
+ loaderContext.emitError(error);
+ }
+ return plugins;
+}
+const ABSOLUTE_SCHEME = /^[a-z0-9+\-.]+:/i;
+function getURLType(source) {
+ if (source[0] === "/") {
+ if (source[1] === "/") {
+ return "scheme-relative";
+ }
+ return "path-absolute";
+ }
+ if (IS_NATIVE_WIN32_PATH.test(source)) {
+ return "path-absolute";
+ }
+ return ABSOLUTE_SCHEME.test(source) ? "absolute" : "path-relative";
+}
+function normalizeSourceMap(map, resourcePath) {
+ let newMap = map;
+
+ // Some loader emit source map as string
+ // Strip any JSON XSSI avoidance prefix from the string (as documented in the source maps specification), and then parse the string as JSON.
+ if (typeof newMap === "string") {
+ newMap = JSON.parse(newMap);
+ }
+ delete newMap.file;
+ const {
+ sourceRoot
+ } = newMap;
+ delete newMap.sourceRoot;
+ if (newMap.sources) {
+ // Source maps should use forward slash because it is URLs (https://github.com/mozilla/source-map/issues/91)
+ // We should normalize path because previous loaders like `sass-loader` using backslash when generate source map
+ newMap.sources = newMap.sources.map(source => {
+ // Non-standard syntax from `postcss`
+ if (source.indexOf("<") === 0) {
+ return source;
+ }
+ const sourceType = getURLType(source);
+
+ // Do no touch `scheme-relative` and `absolute` URLs
+ if (sourceType === "path-relative" || sourceType === "path-absolute") {
+ const absoluteSource = sourceType === "path-relative" && sourceRoot ? _path.default.resolve(sourceRoot, normalizePath(source)) : normalizePath(source);
+ return _path.default.relative(_path.default.dirname(resourcePath), absoluteSource);
+ }
+ return source;
+ });
+ }
+ return newMap;
+}
+function getPreRequester({
+ loaders,
+ loaderIndex
+}) {
+ const cache = Object.create(null);
+ return number => {
+ if (cache[number]) {
+ return cache[number];
+ }
+ if (number === false) {
+ cache[number] = "";
+ } else {
+ const loadersRequest = loaders.slice(loaderIndex, loaderIndex + 1 + (typeof number !== "number" ? 0 : number)).map(x => x.request).join("!");
+ cache[number] = `-!${loadersRequest}!`;
+ }
+ return cache[number];
+ };
+}
+function getImportCode(imports, options) {
+ let code = "";
+ for (const item of imports) {
+ const {
+ importName,
+ url,
+ icss,
+ type
+ } = item;
+ if (options.esModule) {
+ if (icss && options.modules.namedExport) {
+ code += `import ${options.modules.exportOnlyLocals ? "" : `${importName}, `}* as ${importName}_NAMED___ from ${url};\n`;
+ } else {
+ code += type === "url" ? `var ${importName} = new URL(${url}, import.meta.url);\n` : `import ${importName} from ${url};\n`;
+ }
+ } else {
+ code += `var ${importName} = require(${url});\n`;
+ }
+ }
+ return code ? `// Imports\n${code}` : "";
+}
+function normalizeSourceMapForRuntime(map, loaderContext) {
+ const resultMap = map ? map.toJSON() : null;
+ if (resultMap) {
+ delete resultMap.file;
+
+ /* eslint-disable no-underscore-dangle */
+ if (loaderContext._compilation && loaderContext._compilation.options && loaderContext._compilation.options.devtool && loaderContext._compilation.options.devtool.includes("nosources")) {
+ /* eslint-enable no-underscore-dangle */
+
+ delete resultMap.sourcesContent;
+ }
+ resultMap.sourceRoot = "";
+ resultMap.sources = resultMap.sources.map(source => {
+ // Non-standard syntax from `postcss`
+ if (source.indexOf("<") === 0) {
+ return source;
+ }
+ const sourceType = getURLType(source);
+ if (sourceType !== "path-relative") {
+ return source;
+ }
+ const resourceDirname = _path.default.dirname(loaderContext.resourcePath);
+ const absoluteSource = _path.default.resolve(resourceDirname, source);
+ const contextifyPath = normalizePath(_path.default.relative(loaderContext.rootContext, absoluteSource));
+ return `webpack://./${contextifyPath}`;
+ });
+ }
+ return JSON.stringify(resultMap);
+}
+function printParams(media, dedupe, supports, layer) {
+ let result = "";
+ if (typeof layer !== "undefined") {
+ result = `, ${JSON.stringify(layer)}`;
+ }
+ if (typeof supports !== "undefined") {
+ result = `, ${JSON.stringify(supports)}${result}`;
+ } else if (result.length > 0) {
+ result = `, undefined${result}`;
+ }
+ if (dedupe) {
+ result = `, true${result}`;
+ } else if (result.length > 0) {
+ result = `, false${result}`;
+ }
+ if (media) {
+ result = `${JSON.stringify(media)}${result}`;
+ } else if (result.length > 0) {
+ result = `""${result}`;
+ }
+ return result;
+}
+function getModuleCode(result, api, replacements, options, isTemplateLiteralSupported, loaderContext) {
+ if (options.modules.exportOnlyLocals === true) {
+ return "";
+ }
+ let sourceMapValue = "";
+ if (options.sourceMap) {
+ const sourceMap = result.map;
+ sourceMapValue = `,${normalizeSourceMapForRuntime(sourceMap, loaderContext)}`;
+ }
+ let code = isTemplateLiteralSupported ? convertToTemplateLiteral(result.css) : JSON.stringify(result.css);
+ let beforeCode = `var ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(${options.sourceMap ? "___CSS_LOADER_API_SOURCEMAP_IMPORT___" : "___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___"});\n`;
+ for (const item of api) {
+ const {
+ url,
+ layer,
+ supports,
+ media,
+ dedupe
+ } = item;
+ if (url) {
+ // eslint-disable-next-line no-undefined
+ const printedParam = printParams(media, undefined, supports, layer);
+ beforeCode += `___CSS_LOADER_EXPORT___.push([module.id, ${JSON.stringify(`@import url(${url});`)}${printedParam.length > 0 ? `, ${printedParam}` : ""}]);\n`;
+ } else {
+ const printedParam = printParams(media, dedupe, supports, layer);
+ beforeCode += `___CSS_LOADER_EXPORT___.i(${item.importName}${printedParam.length > 0 ? `, ${printedParam}` : ""});\n`;
+ }
+ }
+ for (const item of replacements) {
+ const {
+ replacementName,
+ importName,
+ localName
+ } = item;
+ if (localName) {
+ code = code.replace(new RegExp(replacementName, "g"), () => options.modules.namedExport ? isTemplateLiteralSupported ? `\${ ${importName}_NAMED___[${JSON.stringify(getValidLocalName(localName, options.modules.exportLocalsConvention))}] }` : `" + ${importName}_NAMED___[${JSON.stringify(getValidLocalName(localName, options.modules.exportLocalsConvention))}] + "` : isTemplateLiteralSupported ? `\${${importName}.locals[${JSON.stringify(localName)}]}` : `" + ${importName}.locals[${JSON.stringify(localName)}] + "`);
+ } else {
+ const {
+ hash,
+ needQuotes
+ } = item;
+ const getUrlOptions = [].concat(hash ? [`hash: ${JSON.stringify(hash)}`] : []).concat(needQuotes ? "needQuotes: true" : []);
+ const preparedOptions = getUrlOptions.length > 0 ? `, { ${getUrlOptions.join(", ")} }` : "";
+ beforeCode += `var ${replacementName} = ___CSS_LOADER_GET_URL_IMPORT___(${importName}${preparedOptions});\n`;
+ code = code.replace(new RegExp(replacementName, "g"), () => isTemplateLiteralSupported ? `\${${replacementName}}` : `" + ${replacementName} + "`);
+ }
+ }
+
+ // Indexes description:
+ // 0 - module id
+ // 1 - CSS code
+ // 2 - media
+ // 3 - source map
+ // 4 - supports
+ // 5 - layer
+ return `${beforeCode}// Module\n___CSS_LOADER_EXPORT___.push([module.id, ${code}, ""${sourceMapValue}]);\n`;
+}
+const SLASH = "\\".charCodeAt(0);
+const BACKTICK = "`".charCodeAt(0);
+const DOLLAR = "$".charCodeAt(0);
+function convertToTemplateLiteral(str) {
+ let escapedString = "";
+ for (let i = 0; i < str.length; i++) {
+ const code = str.charCodeAt(i);
+ escapedString += code === SLASH || code === BACKTICK || code === DOLLAR ? `\\${str[i]}` : str[i];
+ }
+ return `\`${escapedString}\``;
+}
+function dashesCamelCase(str) {
+ return str.replace(/-+(\w)/g, (match, firstLetter) => firstLetter.toUpperCase());
+}
+function getExportCode(exports, replacements, icssPluginUsed, options, isTemplateLiteralSupported) {
+ let code = "// Exports\n";
+ if (icssPluginUsed) {
+ let localsCode = "";
+ let identifierId = 0;
+ const addExportToLocalsCode = (names, value) => {
+ const normalizedNames = Array.isArray(names) ? new Set(names) : new Set([names]);
+ for (const name of normalizedNames) {
+ const serializedValue = isTemplateLiteralSupported ? convertToTemplateLiteral(value) : JSON.stringify(value);
+ if (options.modules.namedExport) {
+ if (options.modules.useExportsAs) {
+ identifierId += 1;
+ const id = `_${identifierId.toString(16)}`;
+ localsCode += `var ${id} = ${serializedValue};\n`;
+ localsCode += `export { ${id} as ${JSON.stringify(name)} };\n`;
+ } else {
+ localsCode += `export var ${name} = ${serializedValue};\n`;
+ }
+ } else {
+ if (localsCode) {
+ localsCode += `,\n`;
+ }
+ localsCode += `\t${JSON.stringify(name)}: ${serializedValue}`;
+ }
+ }
+ };
+ for (const {
+ name,
+ value
+ } of exports) {
+ addExportToLocalsCode(options.modules.exportLocalsConvention(name), value);
+ }
+ for (const item of replacements) {
+ const {
+ replacementName,
+ localName
+ } = item;
+ if (localName) {
+ const {
+ importName
+ } = item;
+ localsCode = localsCode.replace(new RegExp(replacementName, "g"), () => {
+ if (options.modules.namedExport) {
+ return isTemplateLiteralSupported ? `\${${importName}_NAMED___[${JSON.stringify(getValidLocalName(localName, options.modules.exportLocalsConvention))}]}` : `" + ${importName}_NAMED___[${JSON.stringify(getValidLocalName(localName, options.modules.exportLocalsConvention))}] + "`;
+ } else if (options.modules.exportOnlyLocals) {
+ return isTemplateLiteralSupported ? `\${${importName}[${JSON.stringify(localName)}]}` : `" + ${importName}[${JSON.stringify(localName)}] + "`;
+ }
+ return isTemplateLiteralSupported ? `\${${importName}.locals[${JSON.stringify(localName)}]}` : `" + ${importName}.locals[${JSON.stringify(localName)}] + "`;
+ });
+ } else {
+ localsCode = localsCode.replace(new RegExp(replacementName, "g"), () => isTemplateLiteralSupported ? `\${${replacementName}}` : `" + ${replacementName} + "`);
+ }
+ }
+ if (options.modules.exportOnlyLocals) {
+ code += options.modules.namedExport ? localsCode : `${options.esModule ? "export default" : "module.exports ="} {\n${localsCode}\n};\n`;
+ return code;
+ }
+ code += options.modules.namedExport ? localsCode : `___CSS_LOADER_EXPORT___.locals = {${localsCode ? `\n${localsCode}\n` : ""}};\n`;
+ }
+ const isCSSStyleSheetExport = options.exportType === "css-style-sheet";
+ if (isCSSStyleSheetExport) {
+ code += "var ___CSS_LOADER_STYLE_SHEET___ = new CSSStyleSheet();\n";
+ code += "___CSS_LOADER_STYLE_SHEET___.replaceSync(___CSS_LOADER_EXPORT___.toString());\n";
+ }
+ let finalExport;
+ switch (options.exportType) {
+ case "string":
+ finalExport = "___CSS_LOADER_EXPORT___.toString()";
+ break;
+ case "css-style-sheet":
+ finalExport = "___CSS_LOADER_STYLE_SHEET___";
+ break;
+ default:
+ case "array":
+ finalExport = "___CSS_LOADER_EXPORT___";
+ break;
+ }
+ code += `${options.esModule ? "export default" : "module.exports ="} ${finalExport};\n`;
+ return code;
+}
+async function resolveRequests(resolve, context, possibleRequests) {
+ return resolve(context, possibleRequests[0]).then(result => result).catch(error => {
+ const [, ...tailPossibleRequests] = possibleRequests;
+ if (tailPossibleRequests.length === 0) {
+ throw error;
+ }
+ return resolveRequests(resolve, context, tailPossibleRequests);
+ });
+}
+function isURLRequestable(url, options = {}) {
+ // Protocol-relative URLs
+ if (/^\/\//.test(url)) {
+ return {
+ requestable: false,
+ needResolve: false
+ };
+ }
+
+ // `#` URLs
+ if (/^#/.test(url)) {
+ return {
+ requestable: false,
+ needResolve: false
+ };
+ }
+
+ // Data URI
+ if (isDataUrl(url) && options.isSupportDataURL) {
+ try {
+ decodeURIComponent(url);
+ } catch (ignoreError) {
+ return {
+ requestable: false,
+ needResolve: false
+ };
+ }
+ return {
+ requestable: true,
+ needResolve: false
+ };
+ }
+
+ // `file:` protocol
+ if (/^file:/i.test(url)) {
+ return {
+ requestable: true,
+ needResolve: true
+ };
+ }
+
+ // Absolute URLs
+ if (/^[a-z][a-z0-9+.-]*:/i.test(url) && !NATIVE_WIN32_PATH.test(url)) {
+ if (options.isSupportAbsoluteURL && /^https?:/i.test(url)) {
+ return {
+ requestable: true,
+ needResolve: false
+ };
+ }
+ return {
+ requestable: false,
+ needResolve: false
+ };
+ }
+ return {
+ requestable: true,
+ needResolve: true
+ };
+}
+function sort(a, b) {
+ return a.index - b.index;
+}
+function combineRequests(preRequest, url) {
+ const idx = url.indexOf("!=!");
+ return idx !== -1 ? url.slice(0, idx + 3) + preRequest + url.slice(idx + 3) : preRequest + url;
+}
+function warningFactory(warning) {
+ let message = "";
+ if (typeof warning.line !== "undefined") {
+ message += `(${warning.line}:${warning.column}) `;
+ }
+ if (typeof warning.plugin !== "undefined") {
+ message += `from "${warning.plugin}" plugin: `;
+ }
+ message += warning.text;
+ if (warning.node) {
+ message += `\n\nCode:\n ${warning.node.toString()}\n`;
+ }
+ const obj = new Error(message, {
+ cause: warning
+ });
+ obj.stack = null;
+ return obj;
+}
+function syntaxErrorFactory(error) {
+ let message = "\nSyntaxError\n\n";
+ if (typeof error.line !== "undefined") {
+ message += `(${error.line}:${error.column}) `;
+ }
+ if (typeof error.plugin !== "undefined") {
+ message += `from "${error.plugin}" plugin: `;
+ }
+ message += error.file ? `${error.file} ` : " ";
+ message += `${error.reason}`;
+ const code = error.showSourceCode();
+ if (code) {
+ message += `\n\n${code}\n`;
+ }
+ const obj = new Error(message, {
+ cause: error
+ });
+ obj.stack = null;
+ return obj;
+}
Index: frontend/node_modules/css-loader/package.json
===================================================================
--- frontend/node_modules/css-loader/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/css-loader/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,113 @@
+{
+ "name": "css-loader",
+ "version": "6.11.0",
+ "description": "css loader module for webpack",
+ "license": "MIT",
+ "repository": "webpack-contrib/css-loader",
+ "author": "Tobias Koppers @sokra",
+ "homepage": "https://github.com/webpack-contrib/css-loader",
+ "bugs": "https://github.com/webpack-contrib/css-loader/issues",
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/webpack"
+ },
+ "main": "dist/cjs.js",
+ "engines": {
+ "node": ">= 12.13.0"
+ },
+ "scripts": {
+ "start": "npm run build -- -w",
+ "clean": "del-cli dist",
+ "validate:runtime": "es-check es5 \"dist/runtime/**/*.js\"",
+ "prebuild": "npm run clean",
+ "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+ "postbuild": "npm run validate:runtime",
+ "commitlint": "commitlint --from=master",
+ "security": "npm audit --production",
+ "lint:prettier": "prettier --list-different .",
+ "lint:js": "eslint --cache .",
+ "lint:spelling": "cspell \"**/*.*\"",
+ "lint": "npm-run-all -l -p \"lint:**\"",
+ "fix:js": "npm run lint:js -- --fix",
+ "fix:prettier": "npm run lint:prettier -- --write",
+ "fix": "npm-run-all -l fix:js fix:prettier",
+ "test:only": "cross-env NODE_ENV=test jest",
+ "test:watch": "npm run test:only -- --watch",
+ "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+ "pretest": "npm run lint",
+ "test": "npm run test:coverage",
+ "prepare": "husky install && npm run build",
+ "release": "standard-version"
+ },
+ "files": [
+ "dist"
+ ],
+ "peerDependencies": {
+ "@rspack/core": "0.x || 1.x",
+ "webpack": "^5.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@rspack/core": {
+ "optional": true
+ },
+ "webpack": {
+ "optional": true
+ }
+ },
+ "dependencies": {
+ "icss-utils": "^5.1.0",
+ "postcss": "^8.4.33",
+ "postcss-modules-extract-imports": "^3.1.0",
+ "postcss-modules-local-by-default": "^4.0.5",
+ "postcss-modules-scope": "^3.2.0",
+ "postcss-modules-values": "^4.0.0",
+ "postcss-value-parser": "^4.2.0",
+ "semver": "^7.5.4"
+ },
+ "devDependencies": {
+ "@babel/cli": "^7.23.4",
+ "@babel/core": "^7.23.7",
+ "@babel/preset-env": "^7.23.7",
+ "@commitlint/cli": "^16.3.0",
+ "@commitlint/config-conventional": "^16.2.4",
+ "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+ "babel-jest": "^28.1.3",
+ "cross-env": "^7.0.3",
+ "cspell": "^6.31.2",
+ "del": "^6.1.1",
+ "del-cli": "^4.0.1",
+ "es-check": "^7.1.0",
+ "eslint": "^8.54.0",
+ "eslint-config-prettier": "^8.9.0",
+ "eslint-plugin-import": "^2.29.0",
+ "file-loader": "^6.2.0",
+ "husky": "^7.0.1",
+ "jest": "^28.1.3",
+ "jest-environment-jsdom": "^28.1.3",
+ "less": "^4.2.0",
+ "less-loader": "^10.0.1",
+ "lint-staged": "^12.5.0",
+ "memfs": "^3.5.3",
+ "mini-css-extract-plugin": "^2.7.5",
+ "npm-run-all": "^4.1.5",
+ "postcss-loader": "^6.2.1",
+ "postcss-preset-env": "^7.8.3",
+ "prettier": "^2.8.7",
+ "sass": "^1.69.7",
+ "sass-loader": "^12.6.0",
+ "standard-version": "^9.5.0",
+ "strip-ansi": "^6.0.0",
+ "style-loader": "^3.3.2",
+ "stylus": "^0.59.0",
+ "stylus-loader": "^6.1.0",
+ "url-loader": "^4.1.1",
+ "webpack": "^5.89.0"
+ },
+ "keywords": [
+ "webpack",
+ "css",
+ "loader",
+ "url",
+ "import"
+ ]
+}
+
+ 
+
+