Fix bin/publish: copy docs.dist from project root

Fix bin/publish: use correct .env path for rspade_system
Fix bin/publish script: prevent grep exit code 1 from terminating script

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

node_modules/mini-css-extract-plugin/dist/cjs.js

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

node_modules/mini-css-extract-plugin/dist/hmr/hotModuleReplacement.js

@@ -0,0 +1,221 @@
+"use strict";
+
+/* eslint-env browser */
+
+/*
+  eslint-disable
+  no-console,
+  func-names
+*/
+var normalizeUrl = require('./normalize-url');
+
+var srcByModuleId = Object.create(null);
+var noDocument = typeof document === 'undefined';
+var forEach = Array.prototype.forEach;
+
+function debounce(fn, time) {
+  var timeout = 0;
+  return function () {
+    var self = this; // eslint-disable-next-line prefer-rest-params
+
+    var args = arguments;
+
+    var functionCall = function functionCall() {
+      return fn.apply(self, args);
+    };
+
+    clearTimeout(timeout);
+    timeout = setTimeout(functionCall, time);
+  };
+}
+
+function noop() {}
+
+function getCurrentScriptUrl(moduleId) {
+  var src = srcByModuleId[moduleId];
+
+  if (!src) {
+    if (document.currentScript) {
+      src = document.currentScript.src;
+    } else {
+      var scripts = document.getElementsByTagName('script');
+      var lastScriptTag = scripts[scripts.length - 1];
+
+      if (lastScriptTag) {
+        src = lastScriptTag.src;
+      }
+    }
+
+    srcByModuleId[moduleId] = src;
+  }
+
+  return function (fileMap) {
+    if (!src) {
+      return null;
+    }
+
+    var splitResult = src.split(/([^\\/]+)\.js$/);
+    var filename = splitResult && splitResult[1];
+
+    if (!filename) {
+      return [src.replace('.js', '.css')];
+    }
+
+    if (!fileMap) {
+      return [src.replace('.js', '.css')];
+    }
+
+    return fileMap.split(',').map(function (mapRule) {
+      var reg = new RegExp("".concat(filename, "\\.js$"), 'g');
+      return normalizeUrl(src.replace(reg, "".concat(mapRule.replace(/{fileName}/g, filename), ".css")));
+    });
+  };
+}
+
+function updateCss(el, url) {
+  if (!url) {
+    if (!el.href) {
+      return;
+    } // eslint-disable-next-line
+
+
+    url = el.href.split('?')[0];
+  }
+
+  if (!isUrlRequest(url)) {
+    return;
+  }
+
+  if (el.isLoaded === false) {
+    // We seem to be about to replace a css link that hasn't loaded yet.
+    // We're probably changing the same file more than once.
+    return;
+  }
+
+  if (!url || !(url.indexOf('.css') > -1)) {
+    return;
+  } // eslint-disable-next-line no-param-reassign
+
+
+  el.visited = true;
+  var newEl = el.cloneNode();
+  newEl.isLoaded = false;
+  newEl.addEventListener('load', function () {
+    if (newEl.isLoaded) {
+      return;
+    }
+
+    newEl.isLoaded = true;
+    el.parentNode.removeChild(el);
+  });
+  newEl.addEventListener('error', function () {
+    if (newEl.isLoaded) {
+      return;
+    }
+
+    newEl.isLoaded = true;
+    el.parentNode.removeChild(el);
+  });
+  newEl.href = "".concat(url, "?").concat(Date.now());
+
+  if (el.nextSibling) {
+    el.parentNode.insertBefore(newEl, el.nextSibling);
+  } else {
+    el.parentNode.appendChild(newEl);
+  }
+}
+
+function getReloadUrl(href, src) {
+  var ret; // eslint-disable-next-line no-param-reassign
+
+  href = normalizeUrl(href, {
+    stripWWW: false
+  }); // eslint-disable-next-line array-callback-return
+
+  src.some(function (url) {
+    if (href.indexOf(src) > -1) {
+      ret = url;
+    }
+  });
+  return ret;
+}
+
+function reloadStyle(src) {
+  if (!src) {
+    return false;
+  }
+
+  var elements = document.querySelectorAll('link');
+  var loaded = false;
+  forEach.call(elements, function (el) {
+    if (!el.href) {
+      return;
+    }
+
+    var url = getReloadUrl(el.href, src);
+
+    if (!isUrlRequest(url)) {
+      return;
+    }
+
+    if (el.visited === true) {
+      return;
+    }
+
+    if (url) {
+      updateCss(el, url);
+      loaded = true;
+    }
+  });
+  return loaded;
+}
+
+function reloadAll() {
+  var elements = document.querySelectorAll('link');
+  forEach.call(elements, function (el) {
+    if (el.visited === true) {
+      return;
+    }
+
+    updateCss(el);
+  });
+}
+
+function isUrlRequest(url) {
+  // An URL is not an request if
+  // It is not http or https
+  if (!/^https?:/i.test(url)) {
+    return false;
+  }
+
+  return true;
+}
+
+module.exports = function (moduleId, options) {
+  if (noDocument) {
+    console.log('no window.document found, will not HMR CSS');
+    return noop;
+  }
+
+  var getScriptSrc = getCurrentScriptUrl(moduleId);
+
+  function update() {
+    var src = getScriptSrc(options.filename);
+    var reloaded = reloadStyle(src);
+
+    if (options.locals) {
+      console.log('[HMR] Detected local css modules. Reload all css');
+      reloadAll();
+      return;
+    }
+
+    if (reloaded) {
+      console.log('[HMR] css reload %s', src.join(' '));
+    } else {
+      console.log('[HMR] Reload all css');
+      reloadAll();
+    }
+  }
+
+  return debounce(update, 50);
+};

node_modules/mini-css-extract-plugin/dist/hmr/normalize-url.js

@@ -0,0 +1,35 @@
+"use strict";
+
+/* eslint-disable */
+function normalizeUrl(pathComponents) {
+  return pathComponents.reduce(function (accumulator, item) {
+    switch (item) {
+      case '..':
+        accumulator.pop();
+        break;
+
+      case '.':
+        break;
+
+      default:
+        accumulator.push(item);
+    }
+
+    return accumulator;
+  }, []).join('/');
+}
+
+module.exports = function (urlString) {
+  urlString = urlString.trim();
+
+  if (/^data:/i.test(urlString)) {
+    return urlString;
+  }
+
+  var protocol = urlString.indexOf('//') !== -1 ? urlString.split('//')[0] + '//' : '';
+  var components = urlString.replace(new RegExp(protocol, 'i'), '').split('/');
+  var host = components[0].toLowerCase().replace(/\.$/, '');
+  components[0] = '';
+  var path = normalizeUrl(components);
+  return protocol + host + path;
+};

node_modules/mini-css-extract-plugin/dist/index.js

@@ -0,0 +1,912 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.pluginSymbol = exports.pluginName = void 0;
+
+var _schemaUtils = require("schema-utils");
+
+var _pluginOptions = _interopRequireDefault(require("./plugin-options.json"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable class-methods-use-this */
+const pluginName = 'mini-css-extract-plugin';
+exports.pluginName = pluginName;
+const pluginSymbol = Symbol(pluginName);
+exports.pluginSymbol = pluginSymbol;
+const REGEXP_CHUNKHASH = /\[chunkhash(?::(\d+))?\]/i;
+const REGEXP_CONTENTHASH = /\[contenthash(?::(\d+))?\]/i;
+const REGEXP_NAME = /\[name\]/i;
+const DEFAULT_FILENAME = '[name].css';
+const TYPES = new Set([_utils.MODULE_TYPE]);
+const CODE_GENERATION_RESULT = {
+  sources: new Map(),
+  runtimeRequirements: new Set()
+};
+/**
+ * @type WeakMap<webpack, CssModule>
+ */
+
+const cssModuleCache = new WeakMap();
+/**
+ * @type WeakMap<webpack, CssDependency>
+ */
+
+const cssDependencyCache = new WeakMap();
+const registered = new WeakSet();
+
+class MiniCssExtractPlugin {
+  static getCssModule(webpack) {
+    /**
+     * Prevent creation of multiple CssModule classes to allow other integrations to get the current CssModule.
+     */
+    if (cssModuleCache.has(webpack)) {
+      return cssModuleCache.get(webpack);
+    }
+
+    class CssModule extends webpack.Module {
+      constructor({
+        context,
+        identifier,
+        identifierIndex,
+        content,
+        media,
+        sourceMap,
+        assets,
+        assetsInfo
+      }) {
+        super(_utils.MODULE_TYPE, context);
+        this.id = '';
+        this._context = context;
+        this._identifier = identifier;
+        this._identifierIndex = identifierIndex;
+        this.content = content;
+        this.media = media;
+        this.sourceMap = sourceMap;
+        this.assets = assets;
+        this.assetsInfo = assetsInfo;
+        this._needBuild = true;
+      } // no source() so webpack 4 doesn't do add stuff to the bundle
+
+
+      size() {
+        return this.content.length;
+      }
+
+      identifier() {
+        return `css|${this._identifier}|${this._identifierIndex}`;
+      }
+
+      readableIdentifier(requestShortener) {
+        return `css ${requestShortener.shorten(this._identifier)}${this._identifierIndex ? ` (${this._identifierIndex})` : ''}`;
+      } // eslint-disable-next-line class-methods-use-this
+
+
+      getSourceTypes() {
+        return TYPES;
+      } // eslint-disable-next-line class-methods-use-this
+
+
+      codeGeneration() {
+        return CODE_GENERATION_RESULT;
+      }
+
+      nameForCondition() {
+        const resource = this._identifier.split('!').pop();
+
+        const idx = resource.indexOf('?');
+
+        if (idx >= 0) {
+          return resource.substring(0, idx);
+        }
+
+        return resource;
+      }
+
+      updateCacheModule(module) {
+        if (this.content !== module.content || this.media !== module.media || this.sourceMap !== module.sourceMap || this.assets !== module.assets || this.assetsInfo !== module.assetsInfo) {
+          this._needBuild = true;
+          this.content = module.content;
+          this.media = module.media;
+          this.sourceMap = module.sourceMap;
+          this.assets = module.assets;
+          this.assetsInfo = module.assetsInfo;
+        }
+      } // eslint-disable-next-line class-methods-use-this
+
+
+      needRebuild() {
+        return this._needBuild;
+      } // eslint-disable-next-line class-methods-use-this
+
+
+      needBuild(context, callback) {
+        callback(null, this._needBuild);
+      }
+
+      build(options, compilation, resolver, fileSystem, callback) {
+        this.buildInfo = {
+          assets: this.assets,
+          assetsInfo: this.assetsInfo,
+          cacheable: true,
+          hash: this._computeHash(compilation.outputOptions.hashFunction)
+        };
+        this.buildMeta = {};
+        this._needBuild = false;
+        callback();
+      }
+
+      _computeHash(hashFunction) {
+        const hash = webpack.util.createHash(hashFunction);
+        hash.update(this.content);
+        hash.update(this.media || '');
+        hash.update(this.sourceMap || '');
+        return hash.digest('hex');
+      }
+
+      updateHash(hash, context) {
+        super.updateHash(hash, context);
+        hash.update(this.buildInfo.hash);
+      }
+
+      serialize(context) {
+        const {
+          write
+        } = context;
+        write(this._context);
+        write(this._identifier);
+        write(this._identifierIndex);
+        write(this.content);
+        write(this.media);
+        write(this.sourceMap);
+        write(this.assets);
+        write(this.assetsInfo);
+        write(this._needBuild);
+        super.serialize(context);
+      }
+
+      deserialize(context) {
+        this._needBuild = context.read();
+        super.deserialize(context);
+      }
+
+    }
+
+    cssModuleCache.set(webpack, CssModule);
+
+    if (webpack.util && webpack.util.serialization && webpack.util.serialization.register) {
+      webpack.util.serialization.register(CssModule, 'mini-css-extract-plugin/dist/CssModule', null, {
+        serialize(instance, context) {
+          instance.serialize(context);
+        },
+
+        deserialize(context) {
+          const {
+            read
+          } = context;
+          const contextModule = read();
+          const identifier = read();
+          const identifierIndex = read();
+          const content = read();
+          const media = read();
+          const sourceMap = read();
+          const assets = read();
+          const assetsInfo = read();
+          const dep = new CssModule({
+            context: contextModule,
+            identifier,
+            identifierIndex,
+            content,
+            media,
+            sourceMap,
+            assets,
+            assetsInfo
+          });
+          dep.deserialize(context);
+          return dep;
+        }
+
+      });
+    }
+
+    return CssModule;
+  }
+
+  static getCssDependency(webpack) {
+    /**
+     * Prevent creation of multiple CssDependency classes to allow other integrations to get the current CssDependency.
+     */
+    if (cssDependencyCache.has(webpack)) {
+      return cssDependencyCache.get(webpack);
+    } // eslint-disable-next-line no-shadow
+
+
+    class CssDependency extends webpack.Dependency {
+      constructor({
+        identifier,
+        content,
+        media,
+        sourceMap
+      }, context, identifierIndex) {
+        super();
+        this.identifier = identifier;
+        this.identifierIndex = identifierIndex;
+        this.content = content;
+        this.media = media;
+        this.sourceMap = sourceMap;
+        this.context = context; // eslint-disable-next-line no-undefined
+
+        this.assets = undefined; // eslint-disable-next-line no-undefined
+
+        this.assetsInfo = undefined;
+      }
+
+      getResourceIdentifier() {
+        return `css-module-${this.identifier}-${this.identifierIndex}`;
+      } // eslint-disable-next-line class-methods-use-this
+
+
+      getModuleEvaluationSideEffectsState() {
+        return webpack.ModuleGraphConnection.TRANSITIVE_ONLY;
+      }
+
+      serialize(context) {
+        const {
+          write
+        } = context;
+        write(this.identifier);
+        write(this.content);
+        write(this.media);
+        write(this.sourceMap);
+        write(this.context);
+        write(this.identifierIndex);
+        write(this.assets);
+        write(this.assetsInfo);
+        super.serialize(context);
+      }
+
+      deserialize(context) {
+        super.deserialize(context);
+      }
+
+    }
+
+    cssDependencyCache.set(webpack, CssDependency);
+
+    if (webpack.util && webpack.util.serialization && webpack.util.serialization.register) {
+      webpack.util.serialization.register(CssDependency, 'mini-css-extract-plugin/dist/CssDependency', null, {
+        serialize(instance, context) {
+          instance.serialize(context);
+        },
+
+        deserialize(context) {
+          const {
+            read
+          } = context;
+          const dep = new CssDependency({
+            identifier: read(),
+            content: read(),
+            media: read(),
+            sourceMap: read()
+          }, read(), read());
+          const assets = read();
+          const assetsInfo = read();
+          dep.assets = assets;
+          dep.assetsInfo = assetsInfo;
+          dep.deserialize(context);
+          return dep;
+        }
+
+      });
+    }
+
+    return CssDependency;
+  }
+
+  constructor(options = {}) {
+    (0, _schemaUtils.validate)(_pluginOptions.default, options, {
+      name: 'Mini CSS Extract Plugin',
+      baseDataPath: 'options'
+    });
+    this._sortedModulesCache = new WeakMap();
+    this.options = Object.assign({
+      filename: DEFAULT_FILENAME,
+      ignoreOrder: false,
+      experimentalUseImportModule: false
+    }, options);
+    this.runtimeOptions = {
+      insert: options.insert,
+      linkType: // Todo in next major release set default to "false"
+      options.linkType === true || typeof options.linkType === 'undefined' ? 'text/css' : options.linkType,
+      attributes: options.attributes
+    };
+
+    if (!this.options.chunkFilename) {
+      const {
+        filename
+      } = this.options;
+
+      if (typeof filename !== 'function') {
+        const hasName = filename.includes('[name]');
+        const hasId = filename.includes('[id]');
+        const hasChunkHash = filename.includes('[chunkhash]');
+        const hasContentHash = filename.includes('[contenthash]'); // Anything changing depending on chunk is fine
+
+        if (hasChunkHash || hasContentHash || hasName || hasId) {
+          this.options.chunkFilename = filename;
+        } else {
+          // Otherwise prefix "[id]." in front of the basename to make it changing
+          this.options.chunkFilename = filename.replace(/(^|\/)([^/]*(?:\?|$))/, '$1[id].$2');
+        }
+      } else {
+        this.options.chunkFilename = '[id].css';
+      }
+    }
+  }
+  /** @param {import("webpack").Compiler} compiler */
+
+
+  apply(compiler) {
+    const webpack = compiler.webpack ? compiler.webpack : // eslint-disable-next-line global-require
+    require('webpack');
+
+    if (this.options.experimentalUseImportModule) {
+      if (!compiler.options.experiments) {
+        throw new Error('experimentalUseImportModule is only support for webpack >= 5.33.2');
+      }
+
+      if (typeof compiler.options.experiments.executeModule === 'undefined') {
+        // eslint-disable-next-line no-param-reassign
+        compiler.options.experiments.executeModule = true;
+      }
+    } // TODO bug in webpack, remove it after it will be fixed
+    // webpack tries to `require` loader firstly when serializer doesn't found
+
+
+    if (webpack.util && webpack.util.serialization && webpack.util.serialization.registerLoader && !registered.has(webpack)) {
+      registered.add(webpack);
+      webpack.util.serialization.registerLoader(/^mini-css-extract-plugin\//, _utils.trueFn);
+    }
+
+    const isWebpack4 = compiler.webpack ? false : typeof compiler.resolvers !== 'undefined';
+
+    if (!isWebpack4) {
+      const {
+        splitChunks
+      } = compiler.options.optimization;
+
+      if (splitChunks) {
+        if (splitChunks.defaultSizeTypes.includes('...')) {
+          splitChunks.defaultSizeTypes.push(_utils.MODULE_TYPE);
+        }
+      }
+    }
+
+    const CssModule = MiniCssExtractPlugin.getCssModule(webpack);
+    const CssDependency = MiniCssExtractPlugin.getCssDependency(webpack);
+    const NormalModule = compiler.webpack && compiler.webpack.NormalModule ? compiler.webpack.NormalModule : // eslint-disable-next-line global-require
+    require('webpack/lib/NormalModule');
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      const normalModuleHook = typeof NormalModule.getCompilationHooks !== 'undefined' ? NormalModule.getCompilationHooks(compilation).loader : compilation.hooks.normalModuleLoader;
+      normalModuleHook.tap(pluginName, loaderContext => {
+        // eslint-disable-next-line no-param-reassign
+        loaderContext[pluginSymbol] = {
+          experimentalUseImportModule: this.options.experimentalUseImportModule
+        };
+      });
+    });
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      class CssModuleFactory {
+        // eslint-disable-next-line class-methods-use-this
+        create({
+          dependencies: [dependency]
+        }, callback) {
+          callback(null, new CssModule(dependency));
+        }
+
+      }
+
+      compilation.dependencyFactories.set(CssDependency, new CssModuleFactory());
+
+      class CssDependencyTemplate {
+        // eslint-disable-next-line class-methods-use-this
+        apply() {}
+
+      }
+
+      compilation.dependencyTemplates.set(CssDependency, new CssDependencyTemplate());
+
+      if (isWebpack4) {
+        compilation.mainTemplate.hooks.renderManifest.tap(pluginName, (result, {
+          chunk
+        }) => {
+          const {
+            chunkGraph
+          } = compilation;
+          const renderedModules = Array.from(this.getChunkModules(chunk, chunkGraph)).filter(module => module.type === _utils.MODULE_TYPE);
+          const filenameTemplate = chunk.filenameTemplate || this.options.filename;
+
+          if (renderedModules.length > 0) {
+            result.push({
+              render: () => this.renderContentAsset(compiler, compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener),
+              filenameTemplate,
+              pathOptions: {
+                chunk,
+                contentHashType: _utils.MODULE_TYPE
+              },
+              identifier: `${pluginName}.${chunk.id}`,
+              hash: chunk.contentHash[_utils.MODULE_TYPE]
+            });
+          }
+        });
+        compilation.chunkTemplate.hooks.renderManifest.tap(pluginName, (result, {
+          chunk
+        }) => {
+          const {
+            chunkGraph
+          } = compilation;
+          const renderedModules = Array.from(this.getChunkModules(chunk, chunkGraph)).filter(module => module.type === _utils.MODULE_TYPE);
+          const filenameTemplate = chunk.filenameTemplate || this.options.chunkFilename;
+
+          if (renderedModules.length > 0) {
+            result.push({
+              render: () => this.renderContentAsset(compiler, compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener),
+              filenameTemplate,
+              pathOptions: {
+                chunk,
+                contentHashType: _utils.MODULE_TYPE
+              },
+              identifier: `${pluginName}.${chunk.id}`,
+              hash: chunk.contentHash[_utils.MODULE_TYPE]
+            });
+          }
+        });
+      } else {
+        compilation.hooks.renderManifest.tap(pluginName, (result, {
+          chunk
+        }) => {
+          const {
+            chunkGraph
+          } = compilation;
+          const {
+            HotUpdateChunk
+          } = webpack; // We don't need hot update chunks for css
+          // We will use the real asset instead to update
+
+          if (chunk instanceof HotUpdateChunk) {
+            return;
+          }
+
+          const renderedModules = Array.from(this.getChunkModules(chunk, chunkGraph)).filter(module => module.type === _utils.MODULE_TYPE);
+          const filenameTemplate = chunk.canBeInitial() ? this.options.filename : this.options.chunkFilename;
+
+          if (renderedModules.length > 0) {
+            result.push({
+              render: () => this.renderContentAsset(compiler, compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener),
+              filenameTemplate,
+              pathOptions: {
+                chunk,
+                contentHashType: _utils.MODULE_TYPE
+              },
+              identifier: `${pluginName}.${chunk.id}`,
+              hash: chunk.contentHash[_utils.MODULE_TYPE]
+            });
+          }
+        });
+      }
+      /*
+       * For webpack 5 this will be unneeded once the logic uses a RuntimeModule
+       * as the content of runtime modules is hashed and added to the chunk hash automatically
+       * */
+
+
+      if (isWebpack4) {
+        compilation.mainTemplate.hooks.hashForChunk.tap(pluginName, (hash, chunk) => {
+          const {
+            chunkFilename
+          } = this.options;
+
+          if (REGEXP_CHUNKHASH.test(chunkFilename)) {
+            hash.update(JSON.stringify(chunk.getChunkMaps(true).hash));
+          }
+
+          if (REGEXP_CONTENTHASH.test(chunkFilename)) {
+            hash.update(JSON.stringify(chunk.getChunkMaps(true).contentHash[_utils.MODULE_TYPE] || {}));
+          }
+
+          if (REGEXP_NAME.test(chunkFilename)) {
+            hash.update(JSON.stringify(chunk.getChunkMaps(true).name));
+          }
+        });
+      }
+
+      compilation.hooks.contentHash.tap(pluginName, chunk => {
+        const {
+          outputOptions,
+          chunkGraph
+        } = compilation;
+        const modules = isWebpack4 ? Array.from(this.getChunkModules(chunk, chunkGraph)).filter(module => module.type === _utils.MODULE_TYPE) : this.sortModules(compilation, chunk, chunkGraph.getChunkModulesIterableBySourceType(chunk, _utils.MODULE_TYPE), compilation.runtimeTemplate.requestShortener);
+
+        if (modules) {
+          const {
+            hashFunction,
+            hashDigest,
+            hashDigestLength
+          } = outputOptions;
+          const createHash = compiler.webpack ? compiler.webpack.util.createHash : webpack.util.createHash;
+          const hash = createHash(hashFunction);
+
+          if (isWebpack4) {
+            for (const m of modules) {
+              m.updateHash(hash);
+            }
+          } else {
+            for (const m of modules) {
+              hash.update(chunkGraph.getModuleHash(m, chunk.runtime));
+            }
+          } // eslint-disable-next-line no-param-reassign
+
+
+          chunk.contentHash[_utils.MODULE_TYPE] = hash.digest(hashDigest).substring(0, hashDigestLength);
+        }
+      });
+      const {
+        Template
+      } = webpack;
+      const {
+        mainTemplate
+      } = compilation;
+
+      if (isWebpack4) {
+        mainTemplate.hooks.localVars.tap(pluginName, (source, chunk) => {
+          const chunkMap = this.getCssChunkObject(chunk, compilation);
+
+          if (Object.keys(chunkMap).length > 0) {
+            return Template.asString([source, '', '// object to store loaded CSS chunks', 'var installedCssChunks = {', Template.indent(chunk.ids.map(id => `${JSON.stringify(id)}: 0`).join(',\n')), '};']);
+          }
+
+          return source;
+        });
+        mainTemplate.hooks.requireEnsure.tap(pluginName, (source, chunk, hash) => {
+          const chunkMap = this.getCssChunkObject(chunk, compilation);
+
+          if (Object.keys(chunkMap).length > 0) {
+            const chunkMaps = chunk.getChunkMaps();
+            const {
+              crossOriginLoading
+            } = mainTemplate.outputOptions;
+            const linkHrefPath = mainTemplate.getAssetPath(JSON.stringify(this.options.chunkFilename), {
+              hash: `" + ${mainTemplate.renderCurrentHashCode(hash)} + "`,
+              hashWithLength: length => `" + ${mainTemplate.renderCurrentHashCode(hash, length)} + "`,
+              chunk: {
+                id: '" + chunkId + "',
+                hash: `" + ${JSON.stringify(chunkMaps.hash)}[chunkId] + "`,
+
+                hashWithLength(length) {
+                  const shortChunkHashMap = Object.create(null);
+
+                  for (const chunkId of Object.keys(chunkMaps.hash)) {
+                    if (typeof chunkMaps.hash[chunkId] === 'string') {
+                      shortChunkHashMap[chunkId] = chunkMaps.hash[chunkId].substring(0, length);
+                    }
+                  }
+
+                  return `" + ${JSON.stringify(shortChunkHashMap)}[chunkId] + "`;
+                },
+
+                contentHash: {
+                  [_utils.MODULE_TYPE]: `" + ${JSON.stringify(chunkMaps.contentHash[_utils.MODULE_TYPE])}[chunkId] + "`
+                },
+                contentHashWithLength: {
+                  [_utils.MODULE_TYPE]: length => {
+                    const shortContentHashMap = {};
+                    const contentHash = chunkMaps.contentHash[_utils.MODULE_TYPE];
+
+                    for (const chunkId of Object.keys(contentHash)) {
+                      if (typeof contentHash[chunkId] === 'string') {
+                        shortContentHashMap[chunkId] = contentHash[chunkId].substring(0, length);
+                      }
+                    }
+
+                    return `" + ${JSON.stringify(shortContentHashMap)}[chunkId] + "`;
+                  }
+                },
+                name: `" + (${JSON.stringify(chunkMaps.name)}[chunkId]||chunkId) + "`
+              },
+              contentHashType: _utils.MODULE_TYPE
+            });
+            return Template.asString([source, '', `// ${pluginName} CSS loading`, `var cssChunks = ${JSON.stringify(chunkMap)};`, 'if(installedCssChunks[chunkId]) promises.push(installedCssChunks[chunkId]);', 'else if(installedCssChunks[chunkId] !== 0 && cssChunks[chunkId]) {', Template.indent(['promises.push(installedCssChunks[chunkId] = new Promise(function(resolve, reject) {', Template.indent([`var href = ${linkHrefPath};`, `var fullhref = ${mainTemplate.requireFn}.p + href;`, 'var existingLinkTags = document.getElementsByTagName("link");', 'for(var i = 0; i < existingLinkTags.length; i++) {', Template.indent(['var tag = existingLinkTags[i];', 'var dataHref = tag.getAttribute("data-href") || tag.getAttribute("href");', 'if(tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return resolve();']), '}', 'var existingStyleTags = document.getElementsByTagName("style");', 'for(var i = 0; i < existingStyleTags.length; i++) {', Template.indent(['var tag = existingStyleTags[i];', 'var dataHref = tag.getAttribute("data-href");', 'if(dataHref === href || dataHref === fullhref) return resolve();']), '}', 'var linkTag = document.createElement("link");', this.runtimeOptions.attributes ? Template.asString(Object.entries(this.runtimeOptions.attributes).map(entry => {
+              const [key, value] = entry;
+              return `linkTag.setAttribute(${JSON.stringify(key)}, ${JSON.stringify(value)});`;
+            })) : '', 'linkTag.rel = "stylesheet";', this.runtimeOptions.linkType ? `linkTag.type = ${JSON.stringify(this.runtimeOptions.linkType)};` : '', 'var onLinkComplete = function (event) {', Template.indent(['// avoid mem leaks.', 'linkTag.onerror = linkTag.onload = null;', "if (event.type === 'load') {", Template.indent(['resolve();']), '} else {', Template.indent(["var errorType = event && (event.type === 'load' ? 'missing' : event.type);", 'var realHref = event && event.target && event.target.href || fullhref;', 'var err = new Error("Loading CSS chunk " + chunkId + " failed.\\n(" + realHref + ")");', 'err.code = "CSS_CHUNK_LOAD_FAILED";', 'err.type = errorType;', 'err.request = realHref;', 'delete installedCssChunks[chunkId]', 'linkTag.parentNode.removeChild(linkTag)', 'reject(err);']), '}']), '};', 'linkTag.onerror = linkTag.onload = onLinkComplete;', 'linkTag.href = fullhref;', crossOriginLoading ? Template.asString([`if (linkTag.href.indexOf(window.location.origin + '/') !== 0) {`, Template.indent(`linkTag.crossOrigin = ${JSON.stringify(crossOriginLoading)};`), '}']) : '', typeof this.runtimeOptions.insert !== 'undefined' ? typeof this.runtimeOptions.insert === 'function' ? `(${this.runtimeOptions.insert.toString()})(linkTag)` : Template.asString([`var target = document.querySelector("${this.runtimeOptions.insert}");`, `target.parentNode.insertBefore(linkTag, target.nextSibling);`]) : Template.asString(['document.head.appendChild(linkTag);'])]), '}).then(function() {', Template.indent(['installedCssChunks[chunkId] = 0;']), '}));']), '}']);
+          }
+
+          return source;
+        });
+      } else {
+        const {
+          RuntimeGlobals,
+          runtime
+        } = webpack; // eslint-disable-next-line no-shadow
+
+        const getCssChunkObject = (mainChunk, compilation) => {
+          const obj = {};
+          const {
+            chunkGraph
+          } = compilation;
+
+          for (const chunk of mainChunk.getAllAsyncChunks()) {
+            const modules = chunkGraph.getOrderedChunkModulesIterable(chunk, _utils.compareModulesByIdentifier);
+
+            for (const module of modules) {
+              if (module.type === _utils.MODULE_TYPE) {
+                obj[chunk.id] = 1;
+                break;
+              }
+            }
+          }
+
+          return obj;
+        };
+
+        const {
+          RuntimeModule
+        } = webpack;
+
+        class CssLoadingRuntimeModule extends RuntimeModule {
+          constructor(runtimeRequirements, runtimeOptions) {
+            super('css loading', 10);
+            this.runtimeRequirements = runtimeRequirements;
+            this.runtimeOptions = runtimeOptions;
+          }
+
+          generate() {
+            const {
+              chunk,
+              runtimeRequirements
+            } = this;
+            const {
+              runtimeTemplate,
+              outputOptions: {
+                crossOriginLoading
+              }
+            } = this.compilation;
+            const chunkMap = getCssChunkObject(chunk, this.compilation);
+            const withLoading = runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) && Object.keys(chunkMap).length > 0;
+            const withHmr = runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers);
+
+            if (!withLoading && !withHmr) {
+              return null;
+            }
+
+            return Template.asString([`var createStylesheet = ${runtimeTemplate.basicFunction('chunkId, fullhref, resolve, reject', ['var linkTag = document.createElement("link");', this.runtimeOptions.attributes ? Template.asString(Object.entries(this.runtimeOptions.attributes).map(entry => {
+              const [key, value] = entry;
+              return `linkTag.setAttribute(${JSON.stringify(key)}, ${JSON.stringify(value)});`;
+            })) : '', 'linkTag.rel = "stylesheet";', this.runtimeOptions.linkType ? `linkTag.type = ${JSON.stringify(this.runtimeOptions.linkType)};` : '', `var onLinkComplete = ${runtimeTemplate.basicFunction('event', ['// avoid mem leaks.', 'linkTag.onerror = linkTag.onload = null;', "if (event.type === 'load') {", Template.indent(['resolve();']), '} else {', Template.indent(["var errorType = event && (event.type === 'load' ? 'missing' : event.type);", 'var realHref = event && event.target && event.target.href || fullhref;', 'var err = new Error("Loading CSS chunk " + chunkId + " failed.\\n(" + realHref + ")");', 'err.code = "CSS_CHUNK_LOAD_FAILED";', 'err.type = errorType;', 'err.request = realHref;', 'linkTag.parentNode.removeChild(linkTag)', 'reject(err);']), '}'])}`, 'linkTag.onerror = linkTag.onload = onLinkComplete;', 'linkTag.href = fullhref;', crossOriginLoading ? Template.asString([`if (linkTag.href.indexOf(window.location.origin + '/') !== 0) {`, Template.indent(`linkTag.crossOrigin = ${JSON.stringify(crossOriginLoading)};`), '}']) : '', typeof this.runtimeOptions.insert !== 'undefined' ? typeof this.runtimeOptions.insert === 'function' ? `(${this.runtimeOptions.insert.toString()})(linkTag)` : Template.asString([`var target = document.querySelector("${this.runtimeOptions.insert}");`, `target.parentNode.insertBefore(linkTag, target.nextSibling);`]) : Template.asString(['document.head.appendChild(linkTag);']), 'return linkTag;'])};`, `var findStylesheet = ${runtimeTemplate.basicFunction('href, fullhref', ['var existingLinkTags = document.getElementsByTagName("link");', 'for(var i = 0; i < existingLinkTags.length; i++) {', Template.indent(['var tag = existingLinkTags[i];', 'var dataHref = tag.getAttribute("data-href") || tag.getAttribute("href");', 'if(tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return tag;']), '}', 'var existingStyleTags = document.getElementsByTagName("style");', 'for(var i = 0; i < existingStyleTags.length; i++) {', Template.indent(['var tag = existingStyleTags[i];', 'var dataHref = tag.getAttribute("data-href");', 'if(dataHref === href || dataHref === fullhref) return tag;']), '}'])};`, `var loadStylesheet = ${runtimeTemplate.basicFunction('chunkId', `return new Promise(${runtimeTemplate.basicFunction('resolve, reject', [`var href = ${RuntimeGlobals.require}.miniCssF(chunkId);`, `var fullhref = ${RuntimeGlobals.publicPath} + href;`, 'if(findStylesheet(href, fullhref)) return resolve();', 'createStylesheet(chunkId, fullhref, resolve, reject);'])});`)}`, withLoading ? Template.asString(['// object to store loaded CSS chunks', 'var installedCssChunks = {', Template.indent(chunk.ids.map(id => `${JSON.stringify(id)}: 0`).join(',\n')), '};', '', `${RuntimeGlobals.ensureChunkHandlers}.miniCss = ${runtimeTemplate.basicFunction('chunkId, promises', [`var cssChunks = ${JSON.stringify(chunkMap)};`, 'if(installedCssChunks[chunkId]) promises.push(installedCssChunks[chunkId]);', 'else if(installedCssChunks[chunkId] !== 0 && cssChunks[chunkId]) {', Template.indent([`promises.push(installedCssChunks[chunkId] = loadStylesheet(chunkId).then(${runtimeTemplate.basicFunction('', 'installedCssChunks[chunkId] = 0;')}, ${runtimeTemplate.basicFunction('e', ['delete installedCssChunks[chunkId];', 'throw e;'])}));`]), '}'])};`]) : '// no chunk loading', '', withHmr ? Template.asString(['var oldTags = [];', 'var newTags = [];', `var applyHandler = ${runtimeTemplate.basicFunction('options', [`return { dispose: ${runtimeTemplate.basicFunction('', ['for(var i = 0; i < oldTags.length; i++) {', Template.indent(['var oldTag = oldTags[i];', 'if(oldTag.parentNode) oldTag.parentNode.removeChild(oldTag);']), '}', 'oldTags.length = 0;'])}, apply: ${runtimeTemplate.basicFunction('', ['for(var i = 0; i < newTags.length; i++) newTags[i].rel = "stylesheet";', 'newTags.length = 0;'])} };`])}`, `${RuntimeGlobals.hmrDownloadUpdateHandlers}.miniCss = ${runtimeTemplate.basicFunction('chunkIds, removedChunks, removedModules, promises, applyHandlers, updatedModulesList', ['applyHandlers.push(applyHandler);', `chunkIds.forEach(${runtimeTemplate.basicFunction('chunkId', [`var href = ${RuntimeGlobals.require}.miniCssF(chunkId);`, `var fullhref = ${RuntimeGlobals.publicPath} + href;`, 'var oldTag = findStylesheet(href, fullhref);', 'if(!oldTag) return;', `promises.push(new Promise(${runtimeTemplate.basicFunction('resolve, reject', [`var tag = createStylesheet(chunkId, fullhref, ${runtimeTemplate.basicFunction('', ['tag.as = "style";', 'tag.rel = "preload";', 'resolve();'])}, reject);`, 'oldTags.push(oldTag);', 'newTags.push(tag);'])}));`])});`])}`]) : '// no hmr']);
+          }
+
+        }
+
+        const enabledChunks = new WeakSet();
+
+        const handler = (chunk, set) => {
+          if (enabledChunks.has(chunk)) {
+            return;
+          }
+
+          enabledChunks.add(chunk);
+
+          if (typeof this.options.chunkFilename === 'string' && /\[(full)?hash(:\d+)?\]/.test(this.options.chunkFilename)) {
+            set.add(RuntimeGlobals.getFullHash);
+          }
+
+          set.add(RuntimeGlobals.publicPath);
+          compilation.addRuntimeModule(chunk, new runtime.GetChunkFilenameRuntimeModule(_utils.MODULE_TYPE, 'mini-css', `${RuntimeGlobals.require}.miniCssF`, referencedChunk => {
+            if (!referencedChunk.contentHash[_utils.MODULE_TYPE]) {
+              return false;
+            }
+
+            return referencedChunk.canBeInitial() ? this.options.filename : this.options.chunkFilename;
+          }, true));
+          compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set, this.runtimeOptions));
+        };
+
+        compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.ensureChunkHandlers).tap(pluginName, handler);
+        compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.hmrDownloadUpdateHandlers).tap(pluginName, handler);
+      }
+    });
+  }
+
+  getChunkModules(chunk, chunkGraph) {
+    return typeof chunkGraph !== 'undefined' ? chunkGraph.getOrderedChunkModulesIterable(chunk, _utils.compareModulesByIdentifier) : chunk.modulesIterable;
+  }
+
+  getCssChunkObject(mainChunk, compilation) {
+    const obj = {};
+    const {
+      chunkGraph
+    } = compilation;
+
+    for (const chunk of mainChunk.getAllAsyncChunks()) {
+      for (const module of this.getChunkModules(chunk, chunkGraph)) {
+        if (module.type === _utils.MODULE_TYPE) {
+          obj[chunk.id] = 1;
+          break;
+        }
+      }
+    }
+
+    return obj;
+  }
+
+  sortModules(compilation, chunk, modules, requestShortener) {
+    let usedModules = this._sortedModulesCache.get(chunk);
+
+    if (usedModules || !modules) {
+      return usedModules;
+    }
+
+    const modulesList = [...modules];
+    const [chunkGroup] = chunk.groupsIterable;
+    const moduleIndexFunctionName = typeof compilation.chunkGraph !== 'undefined' ? 'getModulePostOrderIndex' : 'getModuleIndex2';
+
+    if (typeof chunkGroup[moduleIndexFunctionName] === 'function') {
+      // Store dependencies for modules
+      const moduleDependencies = new Map(modulesList.map(m => [m, new Set()]));
+      const moduleDependenciesReasons = new Map(modulesList.map(m => [m, new Map()])); // Get ordered list of modules per chunk group
+      // This loop also gathers dependencies from the ordered lists
+      // Lists are in reverse order to allow to use Array.pop()
+
+      const modulesByChunkGroup = Array.from(chunk.groupsIterable, cg => {
+        const sortedModules = modulesList.map(m => {
+          return {
+            module: m,
+            index: cg[moduleIndexFunctionName](m)
+          };
+        }) // eslint-disable-next-line no-undefined
+        .filter(item => item.index !== undefined).sort((a, b) => b.index - a.index).map(item => item.module);
+
+        for (let i = 0; i < sortedModules.length; i++) {
+          const set = moduleDependencies.get(sortedModules[i]);
+          const reasons = moduleDependenciesReasons.get(sortedModules[i]);
+
+          for (let j = i + 1; j < sortedModules.length; j++) {
+            const module = sortedModules[j];
+            set.add(module);
+            const reason = reasons.get(module) || new Set();
+            reason.add(cg);
+            reasons.set(module, reason);
+          }
+        }
+
+        return sortedModules;
+      }); // set with already included modules in correct order
+
+      usedModules = new Set();
+
+      const unusedModulesFilter = m => !usedModules.has(m);
+
+      while (usedModules.size < modulesList.length) {
+        let success = false;
+        let bestMatch;
+        let bestMatchDeps; // get first module where dependencies are fulfilled
+
+        for (const list of modulesByChunkGroup) {
+          // skip and remove already added modules
+          while (list.length > 0 && usedModules.has(list[list.length - 1])) {
+            list.pop();
+          } // skip empty lists
+
+
+          if (list.length !== 0) {
+            const module = list[list.length - 1];
+            const deps = moduleDependencies.get(module); // determine dependencies that are not yet included
+
+            const failedDeps = Array.from(deps).filter(unusedModulesFilter); // store best match for fallback behavior
+
+            if (!bestMatchDeps || bestMatchDeps.length > failedDeps.length) {
+              bestMatch = list;
+              bestMatchDeps = failedDeps;
+            }
+
+            if (failedDeps.length === 0) {
+              // use this module and remove it from list
+              usedModules.add(list.pop());
+              success = true;
+              break;
+            }
+          }
+        }
+
+        if (!success) {
+          // no module found => there is a conflict
+          // use list with fewest failed deps
+          // and emit a warning
+          const fallbackModule = bestMatch.pop();
+
+          if (!this.options.ignoreOrder) {
+            const reasons = moduleDependenciesReasons.get(fallbackModule);
+            compilation.warnings.push(new Error([`chunk ${chunk.name || chunk.id} [${pluginName}]`, 'Conflicting order. Following module has been added:', ` * ${fallbackModule.readableIdentifier(requestShortener)}`, 'despite it was not able to fulfill desired ordering with these modules:', ...bestMatchDeps.map(m => {
+              const goodReasonsMap = moduleDependenciesReasons.get(m);
+              const goodReasons = goodReasonsMap && goodReasonsMap.get(fallbackModule);
+              const failedChunkGroups = Array.from(reasons.get(m), cg => cg.name).join(', ');
+              const goodChunkGroups = goodReasons && Array.from(goodReasons, cg => cg.name).join(', ');
+              return [` * ${m.readableIdentifier(requestShortener)}`, `   - couldn't fulfill desired order of chunk group(s) ${failedChunkGroups}`, goodChunkGroups && `   - while fulfilling desired order of chunk group(s) ${goodChunkGroups}`].filter(Boolean).join('\n');
+            })].join('\n')));
+          }
+
+          usedModules.add(fallbackModule);
+        }
+      }
+    } else {
+      // fallback for older webpack versions
+      // (to avoid a breaking change)
+      // TODO remove this in next major version
+      // and increase minimum webpack version to 4.12.0
+      modulesList.sort((a, b) => a.index2 - b.index2);
+      usedModules = modulesList;
+    }
+
+    this._sortedModulesCache.set(chunk, usedModules);
+
+    return usedModules;
+  }
+
+  renderContentAsset(compiler, compilation, chunk, modules, requestShortener) {
+    const usedModules = this.sortModules(compilation, chunk, modules, requestShortener); // TODO remove after drop webpack v4
+
+    const {
+      ConcatSource,
+      SourceMapSource,
+      RawSource
+    } = compiler.webpack ? compiler.webpack.sources : // eslint-disable-next-line global-require
+    require('webpack-sources');
+    const source = new ConcatSource();
+    const externalsSource = new ConcatSource();
+
+    for (const m of usedModules) {
+      let content = m.content.toString();
+
+      if (/^@import url/.test(content)) {
+        // HACK for IE
+        // http://stackoverflow.com/a/14676665/1458162
+        if (m.media) {
+          // insert media into the @import
+          // this is rar
+          // TODO improve this and parse the CSS to support multiple medias
+          content = content.replace(/;|\s*$/, m.media);
+        }
+
+        externalsSource.add(content);
+        externalsSource.add('\n');
+      } else {
+        if (m.media) {
+          source.add(`@media ${m.media} {\n`);
+        }
+
+        if (m.sourceMap) {
+          source.add(new SourceMapSource(content, m.readableIdentifier(requestShortener), m.sourceMap.toString()));
+        } else {
+          source.add(new RawSource(content, m.readableIdentifier(requestShortener)));
+        }
+
+        source.add('\n');
+
+        if (m.media) {
+          source.add('}\n');
+        }
+      }
+    }
+
+    return new ConcatSource(externalsSource, source);
+  }
+
+}
+
+MiniCssExtractPlugin.loader = require.resolve('./loader');
+var _default = MiniCssExtractPlugin;
+exports.default = _default;

node_modules/mini-css-extract-plugin/dist/loader-options.json

@@ -0,0 +1,35 @@
+{
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "publicPath": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "emit": {
+      "type": "boolean"
+    },
+    "esModule": {
+      "type": "boolean"
+    },
+    "layer": {
+      "type": "string"
+    },
+    "modules": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "namedExport": {
+          "description": "Enables/disables ES modules named export for locals (https://webpack.js.org/plugins/mini-css-extract-plugin/#namedexport).",
+          "type": "boolean"
+        }
+      }
+    }
+  }
+}

node_modules/mini-css-extract-plugin/dist/loader.js

@@ -0,0 +1,327 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pitch = pitch;
+exports.default = _default;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _loaderUtils = _interopRequireDefault(require("loader-utils"));
+
+var _schemaUtils = require("schema-utils");
+
+var _utils = require("./utils");
+
+var _loaderOptions = _interopRequireDefault(require("./loader-options.json"));
+
+var _index = _interopRequireWildcard(require("./index"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function hotLoader(content, context) {
+  const accept = context.locals ? '' : 'module.hot.accept(undefined, cssReload);';
+  return `${content}
+    if(module.hot) {
+      // ${Date.now()}
+      var cssReload = require(${_loaderUtils.default.stringifyRequest(context.context, _path.default.join(__dirname, 'hmr/hotModuleReplacement.js'))})(module.id, ${JSON.stringify({ ...context.options,
+    locals: !!context.locals
+  })});
+      module.hot.dispose(cssReload);
+      ${accept}
+    }
+  `;
+}
+
+function pitch(request) {
+  const options = _loaderUtils.default.getOptions(this) || {};
+  (0, _schemaUtils.validate)(_loaderOptions.default, options, {
+    name: 'Mini CSS Extract Plugin Loader',
+    baseDataPath: 'options'
+  });
+  const callback = this.async();
+  const optionsFromPlugin = this[_index.pluginSymbol];
+
+  if (!optionsFromPlugin) {
+    callback(new Error("You forgot to add 'mini-css-extract-plugin' plugin (i.e. `{ plugins: [new MiniCssExtractPlugin()] }`), please read https://github.com/webpack-contrib/mini-css-extract-plugin#getting-started"));
+    return;
+  } // TODO simplify after drop  webpack v4
+  // eslint-disable-next-line global-require
+
+
+  const webpack = this._compiler.webpack || require('webpack');
+
+  const handleExports = (originalExports, compilation, assets, assetsInfo) => {
+    let locals;
+    const esModule = typeof options.esModule !== 'undefined' ? options.esModule : true;
+    const namedExport = esModule && options.modules && options.modules.namedExport;
+
+    const addDependencies = dependencies => {
+      if (!Array.isArray(dependencies) && dependencies != null) {
+        throw new Error(`Exported value was not extracted as an array: ${JSON.stringify(dependencies)}`);
+      }
+
+      const identifierCountMap = new Map();
+      const emit = typeof options.emit !== 'undefined' ? options.emit : true;
+      let lastDep;
+
+      for (const dependency of dependencies) {
+        if (!dependency.identifier || !emit) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        const count = identifierCountMap.get(dependency.identifier) || 0;
+
+        const CssDependency = _index.default.getCssDependency(webpack);
+
+        this._module.addDependency(lastDep = new CssDependency(dependency, dependency.context, count));
+
+        identifierCountMap.set(dependency.identifier, count + 1);
+      }
+
+      if (lastDep && assets) {
+        lastDep.assets = assets;
+        lastDep.assetsInfo = assetsInfo;
+      }
+    };
+
+    try {
+      // eslint-disable-next-line no-underscore-dangle
+      const exports = originalExports.__esModule ? originalExports.default : originalExports;
+
+      if (namedExport) {
+        Object.keys(originalExports).forEach(key => {
+          if (key !== 'default') {
+            if (!locals) {
+              locals = {};
+            }
+
+            locals[key] = originalExports[key];
+          }
+        });
+      } else {
+        locals = exports && exports.locals;
+      }
+
+      let dependencies;
+
+      if (!Array.isArray(exports)) {
+        dependencies = [[null, exports]];
+      } else {
+        dependencies = exports.map(([id, content, media, sourceMap]) => {
+          let identifier = id;
+          let context;
+
+          if (compilation) {
+            const module = (0, _utils.findModuleById)(compilation, id);
+            identifier = module.identifier();
+            ({
+              context
+            } = module);
+          } else {
+            // TODO check if this context is used somewhere
+            context = this.rootContext;
+          }
+
+          return {
+            identifier,
+            context,
+            content: Buffer.from(content),
+            media,
+            sourceMap: sourceMap ? Buffer.from(JSON.stringify(sourceMap)) : // eslint-disable-next-line no-undefined
+            undefined
+          };
+        });
+      }
+
+      addDependencies(dependencies);
+    } catch (e) {
+      return callback(e);
+    }
+
+    const result = locals ? namedExport ? Object.keys(locals).map(key => `\nexport var ${key} = ${JSON.stringify(locals[key])};`).join('') : `\n${esModule ? 'export default' : 'module.exports ='} ${JSON.stringify(locals)};` : esModule ? `\nexport {};` : '';
+    let resultSource = `// extracted by ${_index.pluginName}`;
+    resultSource += this.hot ? hotLoader(result, {
+      context: this.context,
+      options,
+      locals
+    }) : result;
+    return callback(null, resultSource);
+  };
+
+  const publicPath = typeof options.publicPath === 'string' ? options.publicPath === 'auto' ? '' : options.publicPath === '' || options.publicPath.endsWith('/') ? options.publicPath : `${options.publicPath}/` : typeof options.publicPath === 'function' ? options.publicPath(this.resourcePath, this.rootContext) : this._compilation.outputOptions.publicPath === 'auto' ? '' : this._compilation.outputOptions.publicPath;
+
+  if (optionsFromPlugin.experimentalUseImportModule) {
+    if (!this.importModule) {
+      callback(new Error("You are using experimentalUseImportModule but 'this.importModule' is not available in loader context. You need to have at least webpack 5.33.2."));
+      return;
+    }
+
+    this.importModule(`${this.resourcePath}.webpack[javascript/auto]!=!${request}`, {
+      layer: options.layer,
+      publicPath
+    }, (err, exports) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      handleExports(exports);
+    });
+    return;
+  }
+
+  const loaders = this.loaders.slice(this.loaderIndex + 1);
+  this.addDependency(this.resourcePath);
+  const childFilename = '*';
+  const outputOptions = {
+    filename: childFilename,
+    publicPath
+  };
+
+  const childCompiler = this._compilation.createChildCompiler(`${_index.pluginName} ${request}`, outputOptions); // The templates are compiled and executed by NodeJS - similar to server side rendering
+  // Unfortunately this causes issues as some loaders require an absolute URL to support ES Modules
+  // The following config enables relative URL support for the child compiler
+
+
+  childCompiler.options.module = { ...childCompiler.options.module
+  };
+  childCompiler.options.module.parser = { ...childCompiler.options.module.parser
+  };
+  childCompiler.options.module.parser.javascript = { ...childCompiler.options.module.parser.javascript,
+    url: 'relative'
+  };
+  const {
+    NodeTemplatePlugin
+  } = webpack.node;
+  const NodeTargetPlugin = webpack.node.NodeTargetPlugin ? webpack.node.NodeTargetPlugin : // eslint-disable-next-line global-require
+  require('webpack/lib/node/NodeTargetPlugin');
+  new NodeTemplatePlugin(outputOptions).apply(childCompiler);
+  new NodeTargetPlugin().apply(childCompiler);
+  const {
+    EntryOptionPlugin
+  } = webpack;
+
+  if (EntryOptionPlugin) {
+    const {
+      library: {
+        EnableLibraryPlugin
+      }
+    } = webpack;
+    new EnableLibraryPlugin('commonjs2').apply(childCompiler);
+    EntryOptionPlugin.applyEntryOption(childCompiler, this.context, {
+      child: {
+        library: {
+          type: 'commonjs2'
+        },
+        import: [`!!${request}`]
+      }
+    });
+  } else {
+    const {
+      LibraryTemplatePlugin,
+      SingleEntryPlugin
+    } = webpack;
+    new LibraryTemplatePlugin(null, 'commonjs2').apply(childCompiler);
+    new SingleEntryPlugin(this.context, `!!${request}`, _index.pluginName).apply(childCompiler);
+  }
+
+  const {
+    LimitChunkCountPlugin
+  } = webpack.optimize;
+  new LimitChunkCountPlugin({
+    maxChunks: 1
+  }).apply(childCompiler);
+  const NormalModule = webpack.NormalModule ? webpack.NormalModule : // eslint-disable-next-line global-require
+  require('webpack/lib/NormalModule');
+  childCompiler.hooks.thisCompilation.tap(`${_index.pluginName} loader`, compilation => {
+    const normalModuleHook = typeof NormalModule.getCompilationHooks !== 'undefined' ? NormalModule.getCompilationHooks(compilation).loader : compilation.hooks.normalModuleLoader;
+    normalModuleHook.tap(`${_index.pluginName} loader`, (loaderContext, module) => {
+      if (module.request === request) {
+        // eslint-disable-next-line no-param-reassign
+        module.loaders = loaders.map(loader => {
+          return {
+            loader: loader.path,
+            options: loader.options,
+            ident: loader.ident
+          };
+        });
+      }
+    });
+  });
+  let source;
+  const isWebpack4 = childCompiler.webpack ? false : typeof childCompiler.resolvers !== 'undefined';
+
+  if (isWebpack4) {
+    childCompiler.hooks.afterCompile.tap(_index.pluginName, compilation => {
+      source = compilation.assets[childFilename] && compilation.assets[childFilename].source(); // Remove all chunk assets
+
+      compilation.chunks.forEach(chunk => {
+        chunk.files.forEach(file => {
+          delete compilation.assets[file]; // eslint-disable-line no-param-reassign
+        });
+      });
+    });
+  } else {
+    childCompiler.hooks.compilation.tap(_index.pluginName, compilation => {
+      compilation.hooks.processAssets.tap(_index.pluginName, () => {
+        source = compilation.assets[childFilename] && compilation.assets[childFilename].source(); // console.log(source);
+        // Remove all chunk assets
+
+        compilation.chunks.forEach(chunk => {
+          chunk.files.forEach(file => {
+            compilation.deleteAsset(file);
+          });
+        });
+      });
+    });
+  }
+
+  childCompiler.runAsChild((error, entries, compilation) => {
+    const assets = Object.create(null);
+    const assetsInfo = new Map();
+
+    for (const asset of compilation.getAssets()) {
+      assets[asset.name] = asset.source;
+      assetsInfo.set(asset.name, asset.info);
+    }
+
+    if (error) {
+      return callback(error);
+    }
+
+    if (compilation.errors.length > 0) {
+      return callback(compilation.errors[0]);
+    }
+
+    compilation.fileDependencies.forEach(dep => {
+      this.addDependency(dep);
+    }, this);
+    compilation.contextDependencies.forEach(dep => {
+      this.addContextDependency(dep);
+    }, this);
+
+    if (!source) {
+      return callback(new Error("Didn't get a result from child compiler"));
+    }
+
+    let originalExports;
+
+    try {
+      originalExports = (0, _utils.evalModuleCode)(this, source, request);
+    } catch (e) {
+      return callback(e);
+    }
+
+    return handleExports(originalExports, compilation, assets, assetsInfo);
+  });
+} // eslint-disable-next-line func-names
+
+
+function _default() {}

node_modules/mini-css-extract-plugin/dist/plugin-options.json

@@ -0,0 +1,58 @@
+{
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "filename": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "chunkFilename": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "experimentalUseImportModule": {
+      "description": "Enable the experimental importModule approach instead of using child compilers. This uses less memory and is faster.",
+      "type": "boolean"
+    },
+    "ignoreOrder": {
+      "type": "boolean"
+    },
+    "insert": {
+      "description": "Inserts `<link>` at the given position (https://github.com/webpack-contrib/mini-css-extract-plugin#insert).",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "attributes": {
+      "description": "Adds custom attributes to tag (https://github.com/webpack-contrib/mini-css-extract-plugin#attributes).",
+      "type": "object"
+    },
+    "linkType": {
+      "anyOf": [
+        {
+          "enum": ["text/css"]
+        },
+        {
+          "type": "boolean"
+        }
+      ]
+    }
+  }
+}

node_modules/mini-css-extract-plugin/dist/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trueFn = trueFn;
+exports.findModuleById = findModuleById;
+exports.evalModuleCode = evalModuleCode;
+exports.compareModulesByIdentifier = compareModulesByIdentifier;
+exports.MODULE_TYPE = void 0;
+
+var _module = _interopRequireDefault(require("module"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function trueFn() {
+  return true;
+}
+
+function findModuleById(compilation, id) {
+  const {
+    modules,
+    chunkGraph
+  } = compilation;
+
+  for (const module of modules) {
+    const moduleId = typeof chunkGraph !== 'undefined' ? chunkGraph.getModuleId(module) : module.id;
+
+    if (moduleId === id) {
+      return module;
+    }
+  }
+
+  return null;
+}
+
+function evalModuleCode(loaderContext, code, filename) {
+  const module = new _module.default(filename, loaderContext);
+  module.paths = _module.default._nodeModulePaths(loaderContext.context); // eslint-disable-line no-underscore-dangle
+
+  module.filename = filename;
+
+  module._compile(code, filename); // eslint-disable-line no-underscore-dangle
+
+
+  return module.exports;
+}
+
+function compareIds(a, b) {
+  if (typeof a !== typeof b) {
+    return typeof a < typeof b ? -1 : 1;
+  }
+
+  if (a < b) {
+    return -1;
+  }
+
+  if (a > b) {
+    return 1;
+  }
+
+  return 0;
+}
+
+function compareModulesByIdentifier(a, b) {
+  return compareIds(a.identifier(), b.identifier());
+}
+
+const MODULE_TYPE = 'css/mini-extract';
+exports.MODULE_TYPE = MODULE_TYPE;