настройка webpack

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

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _webpack = _interopRequireDefault(require("webpack"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class CssDependency extends _webpack.default.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;
+  }
+
+  getResourceIdentifier() {
+    return `css-module-${this.identifier}-${this.identifierIndex}`;
+  }
+
+}
+
+exports.default = CssDependency;

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,211 @@
+"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")), {
+        stripWWW: false
+      });
+    });
+  };
+}
+
+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 () {
+    newEl.isLoaded = true;
+    el.parentNode.removeChild(el);
+  });
+  newEl.addEventListener('error', function () {
+    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) {
+  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 && !options.reloadAll) {
+      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/index.js

@@ -0,0 +1,444 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _webpack = _interopRequireDefault(require("webpack"));
+
+var _webpackSources = _interopRequireDefault(require("webpack-sources"));
+
+var _CssDependency = _interopRequireDefault(require("./CssDependency"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable class-methods-use-this */
+const {
+  ConcatSource,
+  SourceMapSource,
+  OriginalSource
+} = _webpackSources.default;
+const {
+  Template,
+  util: {
+    createHash
+  }
+} = _webpack.default;
+const MODULE_TYPE = 'css/mini-extract';
+const pluginName = 'mini-css-extract-plugin';
+const REGEXP_CHUNKHASH = /\[chunkhash(?::(\d+))?\]/i;
+const REGEXP_CONTENTHASH = /\[contenthash(?::(\d+))?\]/i;
+const REGEXP_NAME = /\[name\]/i;
+const REGEXP_PLACEHOLDERS = /\[(name|id|chunkhash)\]/g;
+const DEFAULT_FILENAME = '[name].css';
+
+class CssDependencyTemplate {
+  apply() {}
+
+}
+
+class CssModule extends _webpack.default.Module {
+  constructor(dependency) {
+    super(MODULE_TYPE, dependency.context);
+    this.id = '';
+    this._identifier = dependency.identifier;
+    this._identifierIndex = dependency.identifierIndex;
+    this.content = dependency.content;
+    this.media = dependency.media;
+    this.sourceMap = dependency.sourceMap;
+  } // no source() so webpack 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})` : ''}`;
+  }
+
+  nameForCondition() {
+    const resource = this._identifier.split('!').pop();
+
+    const idx = resource.indexOf('?');
+
+    if (idx >= 0) {
+      return resource.substring(0, idx);
+    }
+
+    return resource;
+  }
+
+  updateCacheModule(module) {
+    this.content = module.content;
+    this.media = module.media;
+    this.sourceMap = module.sourceMap;
+  }
+
+  needRebuild() {
+    return true;
+  }
+
+  build(options, compilation, resolver, fileSystem, callback) {
+    this.buildInfo = {};
+    this.buildMeta = {};
+    callback();
+  }
+
+  updateHash(hash) {
+    super.updateHash(hash);
+    hash.update(this.content);
+    hash.update(this.media || '');
+    hash.update(this.sourceMap ? JSON.stringify(this.sourceMap) : '');
+  }
+
+}
+
+class CssModuleFactory {
+  create({
+    dependencies: [dependency]
+  }, callback) {
+    callback(null, new CssModule(dependency));
+  }
+
+}
+
+class MiniCssExtractPlugin {
+  constructor(options = {}) {
+    this.options = Object.assign({
+      filename: DEFAULT_FILENAME,
+      moduleFilename: () => this.options.filename || DEFAULT_FILENAME,
+      ignoreOrder: false
+    }, options);
+
+    if (!this.options.chunkFilename) {
+      const {
+        filename
+      } = this.options; // Anything changing depending on chunk is fine
+
+      if (filename.match(REGEXP_PLACEHOLDERS)) {
+        this.options.chunkFilename = filename;
+      } else {
+        // Elsewise prefix '[id].' in front of the basename to make it changing
+        this.options.chunkFilename = filename.replace(/(^|\/)([^/]*(?:\?|$))/, '$1[id].$2');
+      }
+    }
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      compilation.dependencyFactories.set(_CssDependency.default, new CssModuleFactory());
+      compilation.dependencyTemplates.set(_CssDependency.default, new CssDependencyTemplate());
+      compilation.mainTemplate.hooks.renderManifest.tap(pluginName, (result, {
+        chunk
+      }) => {
+        const renderedModules = Array.from(chunk.modulesIterable).filter(module => module.type === MODULE_TYPE);
+
+        if (renderedModules.length > 0) {
+          result.push({
+            render: () => this.renderContentAsset(compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener),
+            filenameTemplate: ({
+              chunk: chunkData
+            }) => this.options.moduleFilename(chunkData),
+            pathOptions: {
+              chunk,
+              contentHashType: MODULE_TYPE
+            },
+            identifier: `${pluginName}.${chunk.id}`,
+            hash: chunk.contentHash[MODULE_TYPE]
+          });
+        }
+      });
+      compilation.chunkTemplate.hooks.renderManifest.tap(pluginName, (result, {
+        chunk
+      }) => {
+        const renderedModules = Array.from(chunk.modulesIterable).filter(module => module.type === MODULE_TYPE);
+
+        if (renderedModules.length > 0) {
+          result.push({
+            render: () => this.renderContentAsset(compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener),
+            filenameTemplate: this.options.chunkFilename,
+            pathOptions: {
+              chunk,
+              contentHashType: MODULE_TYPE
+            },
+            identifier: `${pluginName}.${chunk.id}`,
+            hash: chunk.contentHash[MODULE_TYPE]
+          });
+        }
+      });
+      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[MODULE_TYPE] || {}));
+        }
+
+        if (REGEXP_NAME.test(chunkFilename)) {
+          hash.update(JSON.stringify(chunk.getChunkMaps(true).name));
+        }
+      });
+      compilation.hooks.contentHash.tap(pluginName, chunk => {
+        const {
+          outputOptions
+        } = compilation;
+        const {
+          hashFunction,
+          hashDigest,
+          hashDigestLength
+        } = outputOptions;
+        const hash = createHash(hashFunction);
+
+        for (const m of chunk.modulesIterable) {
+          if (m.type === MODULE_TYPE) {
+            m.updateHash(hash);
+          }
+        }
+
+        const {
+          contentHash
+        } = chunk;
+        contentHash[MODULE_TYPE] = hash.digest(hashDigest).substring(0, hashDigestLength);
+      });
+      const {
+        mainTemplate
+      } = compilation;
+      mainTemplate.hooks.localVars.tap(pluginName, (source, chunk) => {
+        const chunkMap = this.getCssChunkObject(chunk);
+
+        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);
+
+        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: {
+                [MODULE_TYPE]: `" + ${JSON.stringify(chunkMaps.contentHash[MODULE_TYPE])}[chunkId] + "`
+              },
+              contentHashWithLength: {
+                [MODULE_TYPE]: length => {
+                  const shortContentHashMap = {};
+                  const contentHash = chunkMaps.contentHash[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: 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");', 'linkTag.rel = "stylesheet";', 'linkTag.type = "text/css";', 'linkTag.onload = resolve;', 'linkTag.onerror = function(event) {', Template.indent(['var request = event && event.target && event.target.src || fullhref;', 'var err = new Error("Loading CSS chunk " + chunkId + " failed.\\n(" + request + ")");', 'err.code = "CSS_CHUNK_LOAD_FAILED";', 'err.request = request;', 'delete installedCssChunks[chunkId]', 'linkTag.parentNode.removeChild(linkTag)', 'reject(err);']), '};', 'linkTag.href = fullhref;', crossOriginLoading ? Template.asString([`if (linkTag.href.indexOf(window.location.origin + '/') !== 0) {`, Template.indent(`linkTag.crossOrigin = ${JSON.stringify(crossOriginLoading)};`), '}']) : '', 'var head = document.getElementsByTagName("head")[0];', 'head.appendChild(linkTag);']), '}).then(function() {', Template.indent(['installedCssChunks[chunkId] = 0;']), '}));']), '}']);
+        }
+
+        return source;
+      });
+    });
+  }
+
+  getCssChunkObject(mainChunk) {
+    const obj = {};
+
+    for (const chunk of mainChunk.getAllAsyncChunks()) {
+      for (const module of chunk.modulesIterable) {
+        if (module.type === MODULE_TYPE) {
+          obj[chunk.id] = 1;
+          break;
+        }
+      }
+    }
+
+    return obj;
+  }
+
+  renderContentAsset(compilation, chunk, modules, requestShortener) {
+    let usedModules;
+    const [chunkGroup] = chunk.groupsIterable;
+
+    if (typeof chunkGroup.getModuleIndex2 === 'function') {
+      // Store dependencies for modules
+      const moduleDependencies = new Map(modules.map(m => [m, new Set()]));
+      const moduleDependenciesReasons = new Map(modules.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 = modules.map(m => {
+          return {
+            module: m,
+            index: cg.getModuleIndex2(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 < modules.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
+      modules.sort((a, b) => a.index2 - b.index2);
+      usedModules = modules;
+    }
+
+    const source = new ConcatSource();
+    const externalsSource = new ConcatSource();
+
+    for (const m of usedModules) {
+      if (/^@import url/.test(m.content)) {
+        // HACK for IE
+        // http://stackoverflow.com/a/14676665/1458162
+        let {
+          content
+        } = m;
+
+        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(m.content, m.readableIdentifier(requestShortener), m.sourceMap));
+        } else {
+          source.add(new OriginalSource(m.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.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pitch = pitch;
+exports.default = _default;
+
+var _module = _interopRequireDefault(require("module"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _loaderUtils = _interopRequireDefault(require("loader-utils"));
+
+var _NodeTemplatePlugin = _interopRequireDefault(require("webpack/lib/node/NodeTemplatePlugin"));
+
+var _NodeTargetPlugin = _interopRequireDefault(require("webpack/lib/node/NodeTargetPlugin"));
+
+var _LibraryTemplatePlugin = _interopRequireDefault(require("webpack/lib/LibraryTemplatePlugin"));
+
+var _SingleEntryPlugin = _interopRequireDefault(require("webpack/lib/SingleEntryPlugin"));
+
+var _LimitChunkCountPlugin = _interopRequireDefault(require("webpack/lib/optimize/LimitChunkCountPlugin"));
+
+var _schemaUtils = _interopRequireDefault(require("schema-utils"));
+
+var _CssDependency = _interopRequireDefault(require("./CssDependency"));
+
+var _options = _interopRequireDefault(require("./options.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const pluginName = 'mini-css-extract-plugin';
+
+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(_objectSpread({}, context.options, {
+    locals: !!context.locals
+  }))});
+      module.hot.dispose(cssReload);
+      ${accept}
+    }
+  `;
+}
+
+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 findModuleById(modules, id) {
+  for (const module of modules) {
+    if (module.id === id) {
+      return module;
+    }
+  }
+
+  return null;
+}
+
+function pitch(request) {
+  const options = _loaderUtils.default.getOptions(this) || {};
+  (0, _schemaUtils.default)(_options.default, options, 'Mini CSS Extract Plugin Loader');
+  const loaders = this.loaders.slice(this.loaderIndex + 1);
+  this.addDependency(this.resourcePath);
+  const childFilename = '*';
+  const publicPath = typeof options.publicPath === 'string' ? options.publicPath === '' || options.publicPath.endsWith('/') ? options.publicPath : `${options.publicPath}/` : typeof options.publicPath === 'function' ? options.publicPath(this.resourcePath, this.rootContext) : this._compilation.outputOptions.publicPath;
+  const outputOptions = {
+    filename: childFilename,
+    publicPath
+  };
+
+  const childCompiler = this._compilation.createChildCompiler(`${pluginName} ${request}`, outputOptions);
+
+  new _NodeTemplatePlugin.default(outputOptions).apply(childCompiler);
+  new _LibraryTemplatePlugin.default(null, 'commonjs2').apply(childCompiler);
+  new _NodeTargetPlugin.default().apply(childCompiler);
+  new _SingleEntryPlugin.default(this.context, `!!${request}`, pluginName).apply(childCompiler);
+  new _LimitChunkCountPlugin.default({
+    maxChunks: 1
+  }).apply(childCompiler);
+  childCompiler.hooks.thisCompilation.tap(`${pluginName} loader`, compilation => {
+    compilation.hooks.normalModuleLoader.tap(`${pluginName} loader`, (loaderContext, module) => {
+      // eslint-disable-next-line no-param-reassign
+      loaderContext.emitFile = this.emitFile;
+
+      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;
+  childCompiler.hooks.afterCompile.tap(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
+      });
+    });
+  });
+  const callback = this.async();
+  childCompiler.runAsChild((err, entries, compilation) => {
+    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();
+
+      for (const dependency of dependencies) {
+        const count = identifierCountMap.get(dependency.identifier) || 0;
+
+        this._module.addDependency(new _CssDependency.default(dependency, dependency.context, count));
+
+        identifierCountMap.set(dependency.identifier, count + 1);
+      }
+    };
+
+    if (err) {
+      return callback(err);
+    }
+
+    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 locals;
+
+    try {
+      let dependencies;
+      let exports = evalModuleCode(this, source, request); // eslint-disable-next-line no-underscore-dangle
+
+      exports = exports.__esModule ? exports.default : exports;
+      locals = exports && exports.locals;
+
+      if (!Array.isArray(exports)) {
+        dependencies = [[null, exports]];
+      } else {
+        dependencies = exports.map(([id, content, media, sourceMap]) => {
+          const module = findModuleById(compilation.modules, id);
+          return {
+            identifier: module.identifier(),
+            context: module.context,
+            content,
+            media,
+            sourceMap
+          };
+        });
+      }
+
+      addDependencies(dependencies);
+    } catch (e) {
+      return callback(e);
+    }
+
+    const esModule = typeof options.esModule !== 'undefined' ? options.esModule : false;
+    const result = locals ? `\n${esModule ? 'export default' : 'module.exports ='} ${JSON.stringify(locals)};` : '';
+    let resultSource = `// extracted by ${pluginName}`;
+    resultSource += options.hmr ? hotLoader(result, {
+      context: this.context,
+      options,
+      locals
+    }) : result;
+    return callback(null, resultSource);
+  });
+}
+
+function _default() {}

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

@@ -0,0 +1,22 @@
+{
+  "additionalProperties": true,
+  "properties": {
+    "publicPath": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "esModule": {
+      "type": "boolean"
+    }
+  },
+  "errorMessages": {
+    "publicPath": "should be {String} or {Function} (https://github.com/webpack-contrib/mini-css-extract-plugin#publicpath)"
+  },
+  "type": "object"
+}