/******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 441:
/***/ (function(module) {

  "use strict";


  class LoadingLoaderError extends Error {
    constructor(message) {
      super(message);
      this.name = "LoaderRunnerError";
      Error.captureStackTrace(this, this.constructor);
    }
  }

  module.exports = LoadingLoaderError;


  /***/ }),

  /***/ 713:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {

  var LoaderLoadingError = __nccwpck_require__(441);
  var url;

  module.exports = function loadLoader(loader, callback) {
    if(loader.type === "module") {
      try {
        if(url === undefined) url = __nccwpck_require__(310);
        var loaderUrl = url.pathToFileURL(loader.path);
        var modulePromise = eval("import(" + JSON.stringify(loaderUrl.toString()) + ")");
        modulePromise.then(function(module) {
          handleResult(loader, module, callback);
        }, callback);
        return;
      } catch(e) {
        callback(e);
      }
    } else {
      try {
        var module = require(loader.path);
      } catch(e) {
        // it is possible for node to choke on a require if the FD descriptor
        // limit has been reached. give it a chance to recover.
        if(e instanceof Error && e.code === "EMFILE") {
          var retry = loadLoader.bind(null, loader, callback);
          if(typeof setImmediate === "function") {
            // node >= 0.9.0
            return setImmediate(retry);
          } else {
            // node < 0.9.0
            return process.nextTick(retry);
          }
        }
        return callback(e);
      }
      return handleResult(loader, module, callback);
    }
  };

  function handleResult(loader, module, callback) {
    if(typeof module !== "function" && typeof module !== "object") {
      return callback(new LoaderLoadingError(
        "Module '" + loader.path + "' is not a loader (export function or es6 module)"
      ));
    }
    loader.normal = typeof module === "function" ? module : module.default;
    loader.pitch = module.pitch;
    loader.raw = module.raw;
    if(typeof loader.normal !== "function" && typeof loader.pitch !== "function") {
      return callback(new LoaderLoadingError(
        "Module '" + loader.path + "' is not a loader (must have normal or pitch function)"
      ));
    }
    callback();
  }


  /***/ }),

  /***/ 147:
  /***/ (function(module) {

  "use strict";
  module.exports = require("fs");

  /***/ }),

  /***/ 310:
  /***/ (function(module) {

  "use strict";
  module.exports = require("url");

  /***/ })

  /******/ 	});
  /************************************************************************/
  /******/ 	// The module cache
  /******/ 	var __webpack_module_cache__ = {};
  /******/ 	
  /******/ 	// The require function
  /******/ 	function __nccwpck_require__(moduleId) {
  /******/ 		// Check if module is in cache
  /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
  /******/ 		if (cachedModule !== undefined) {
  /******/ 			return cachedModule.exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = __webpack_module_cache__[moduleId] = {
  /******/ 			// no module.id needed
  /******/ 			// no module.loaded needed
  /******/ 			exports: {}
  /******/ 		};
  /******/ 	
  /******/ 		// Execute the module function
  /******/ 		var threw = true;
  /******/ 		try {
  /******/ 			__webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
  /******/ 			threw = false;
  /******/ 		} finally {
  /******/ 			if(threw) delete __webpack_module_cache__[moduleId];
  /******/ 		}
  /******/ 	
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/ 	
  /************************************************************************/
  /******/ 	/* webpack/runtime/compat */
  /******/ 	
  /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
  /******/ 	
  /************************************************************************/
  var __webpack_exports__ = {};
  // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
  !function() {
  var exports = __webpack_exports__;
  /*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
  */
  var fs = __nccwpck_require__(147);
  var readFile = fs.readFile.bind(fs);
  var loadLoader = __nccwpck_require__(713);

  function utf8BufferToString(buf) {
    var str = buf.toString("utf-8");
    if(str.charCodeAt(0) === 0xFEFF) {
      return str.substr(1);
    } else {
      return str;
    }
  }

  const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;

  /**
   * @param {string} str the path with query and fragment
   * @returns {{ path: string, query: string, fragment: string }} parsed parts
   */
  function parsePathQueryFragment(str) {
    var match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
    return {
      path: match[1].replace(/\0(.)/g, "$1"),
      query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
      fragment: match[3] || ""
    };
  }

  function dirname(path) {
    if(path === "/") return "/";
    var i = path.lastIndexOf("/");
    var j = path.lastIndexOf("\\");
    var i2 = path.indexOf("/");
    var j2 = path.indexOf("\\");
    var idx = i > j ? i : j;
    var idx2 = i > j ? i2 : j2;
    if(idx < 0) return path;
    if(idx === idx2) return path.substr(0, idx + 1);
    return path.substr(0, idx);
  }

  function createLoaderObject(loader) {
    var obj = {
      path: null,
      query: null,
      fragment: null,
      options: null,
      ident: null,
      normal: null,
      pitch: null,
      raw: null,
      data: null,
      pitchExecuted: false,
      normalExecuted: false
    };
    Object.defineProperty(obj, "request", {
      enumerable: true,
      get: function() {
        return obj.path.replace(/#/g, "\0#") + obj.query.replace(/#/g, "\0#") + obj.fragment;
      },
      set: function(value) {
        if(typeof value === "string") {
          var splittedRequest = parsePathQueryFragment(value);
          obj.path = splittedRequest.path;
          obj.query = splittedRequest.query;
          obj.fragment = splittedRequest.fragment;
          obj.options = undefined;
          obj.ident = undefined;
        } else {
          if(!value.loader)
            throw new Error("request should be a string or object with loader and options (" + JSON.stringify(value) + ")");
          obj.path = value.loader;
          obj.fragment = value.fragment || "";
          obj.type = value.type;
          obj.options = value.options;
          obj.ident = value.ident;
          if(obj.options === null)
            obj.query = "";
          else if(obj.options === undefined)
            obj.query = "";
          else if(typeof obj.options === "string")
            obj.query = "?" + obj.options;
          else if(obj.ident)
            obj.query = "??" + obj.ident;
          else if(typeof obj.options === "object" && obj.options.ident)
            obj.query = "??" + obj.options.ident;
          else
            obj.query = "?" + JSON.stringify(obj.options);
        }
      }
    });
    obj.request = loader;
    if(Object.preventExtensions) {
      Object.preventExtensions(obj);
    }
    return obj;
  }

  function runSyncOrAsync(fn, context, args, callback) {
    var isSync = true;
    var isDone = false;
    var isError = false; // internal error
    var reportedError = false;
    context.async = function async() {
      if(isDone) {
        if(reportedError) return; // ignore
        throw new Error("async(): The callback was already called.");
      }
      isSync = false;
      return innerCallback;
    };
    var innerCallback = context.callback = function() {
      if(isDone) {
        if(reportedError) return; // ignore
        throw new Error("callback(): The callback was already called.");
      }
      isDone = true;
      isSync = false;
      try {
        callback.apply(null, arguments);
      } catch(e) {
        isError = true;
        throw e;
      }
    };
    try {
      var result = (function LOADER_EXECUTION() {
        return fn.apply(context, args);
      }());
      if(isSync) {
        isDone = true;
        if(result === undefined)
          return callback();
        if(result && typeof result === "object" && typeof result.then === "function") {
          return result.then(function(r) {
            callback(null, r);
          }, callback);
        }
        return callback(null, result);
      }
    } catch(e) {
      if(isError) throw e;
      if(isDone) {
        // loader is already "done", so we cannot use the callback function
        // for better debugging we print the error on the console
        if(typeof e === "object" && e.stack) console.error(e.stack);
        else console.error(e);
        return;
      }
      isDone = true;
      reportedError = true;
      callback(e);
    }

  }

  function convertArgs(args, raw) {
    if(!raw && Buffer.isBuffer(args[0]))
      args[0] = utf8BufferToString(args[0]);
    else if(raw && typeof args[0] === "string")
      args[0] = Buffer.from(args[0], "utf-8");
  }

  function iteratePitchingLoaders(options, loaderContext, callback) {
    // abort after last loader
    if(loaderContext.loaderIndex >= loaderContext.loaders.length)
      return processResource(options, loaderContext, callback);

    var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];

    // iterate
    if(currentLoaderObject.pitchExecuted) {
      loaderContext.loaderIndex++;
      return iteratePitchingLoaders(options, loaderContext, callback);
    }

    // load loader module
    loadLoader(currentLoaderObject, function(err) {
      if(err) {
        loaderContext.cacheable(false);
        return callback(err);
      }
      var fn = currentLoaderObject.pitch;
      currentLoaderObject.pitchExecuted = true;
      if(!fn) return iteratePitchingLoaders(options, loaderContext, callback);

      runSyncOrAsync(
        fn,
        loaderContext, [loaderContext.remainingRequest, loaderContext.previousRequest, currentLoaderObject.data = {}],
        function(err) {
          if(err) return callback(err);
          var args = Array.prototype.slice.call(arguments, 1);
          // Determine whether to continue the pitching process based on
          // argument values (as opposed to argument presence) in order
          // to support synchronous and asynchronous usages.
          var hasArg = args.some(function(value) {
            return value !== undefined;
          });
          if(hasArg) {
            loaderContext.loaderIndex--;
            iterateNormalLoaders(options, loaderContext, args, callback);
          } else {
            iteratePitchingLoaders(options, loaderContext, callback);
          }
        }
      );
    });
  }

  function processResource(options, loaderContext, callback) {
    // set loader index to last loader
    loaderContext.loaderIndex = loaderContext.loaders.length - 1;

    var resourcePath = loaderContext.resourcePath;
    if(resourcePath) {
      options.processResource(loaderContext, resourcePath, function(err) {
        if(err) return callback(err);
        var args = Array.prototype.slice.call(arguments, 1);
        options.resourceBuffer = args[0];
        iterateNormalLoaders(options, loaderContext, args, callback);
      });
    } else {
      iterateNormalLoaders(options, loaderContext, [null], callback);
    }
  }

  function iterateNormalLoaders(options, loaderContext, args, callback) {
    if(loaderContext.loaderIndex < 0)
      return callback(null, args);

    var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];

    // iterate
    if(currentLoaderObject.normalExecuted) {
      loaderContext.loaderIndex--;
      return iterateNormalLoaders(options, loaderContext, args, callback);
    }

    var fn = currentLoaderObject.normal;
    currentLoaderObject.normalExecuted = true;
    if(!fn) {
      return iterateNormalLoaders(options, loaderContext, args, callback);
    }

    convertArgs(args, currentLoaderObject.raw);

    runSyncOrAsync(fn, loaderContext, args, function(err) {
      if(err) return callback(err);

      var args = Array.prototype.slice.call(arguments, 1);
      iterateNormalLoaders(options, loaderContext, args, callback);
    });
  }

  exports.getContext = function getContext(resource) {
    var path = parsePathQueryFragment(resource).path;
    return dirname(path);
  };

  exports.runLoaders = function runLoaders(options, callback) {
    // read options
    var resource = options.resource || "";
    var loaders = options.loaders || [];
    var loaderContext = options.context || {};
    var processResource = options.processResource || ((readResource, context, resource, callback) => {
      context.addDependency(resource);
      readResource(resource, callback);
    }).bind(null, options.readResource || readFile);

    //
    var splittedResource = resource && parsePathQueryFragment(resource);
    var resourcePath = splittedResource ? splittedResource.path : undefined;
    var resourceQuery = splittedResource ? splittedResource.query : undefined;
    var resourceFragment = splittedResource ? splittedResource.fragment : undefined;
    var contextDirectory = resourcePath ? dirname(resourcePath) : null;

    // execution state
    var requestCacheable = true;
    var fileDependencies = [];
    var contextDependencies = [];
    var missingDependencies = [];

    // prepare loader objects
    loaders = loaders.map(createLoaderObject);

    loaderContext.context = contextDirectory;
    loaderContext.loaderIndex = 0;
    loaderContext.loaders = loaders;
    loaderContext.resourcePath = resourcePath;
    loaderContext.resourceQuery = resourceQuery;
    loaderContext.resourceFragment = resourceFragment;
    loaderContext.async = null;
    loaderContext.callback = null;
    loaderContext.getOptions = function getOptions() {
      var entry = loaderContext.loaders[loaderContext.loaderIndex];
      return entry.options && typeof entry.options === "object" ? entry.options : {};
    };

    loaderContext.cacheable = function cacheable(flag) {
      if(flag === false) {
        requestCacheable = false;
      }
    };
    loaderContext.dependency = loaderContext.addDependency = function addDependency(file) {
      fileDependencies.push(file);
    };
    loaderContext.addContextDependency = function addContextDependency(context) {
      contextDependencies.push(context);
    };
    loaderContext.addMissingDependency = function addMissingDependency(context) {
      missingDependencies.push(context);
    };
    loaderContext.getDependencies = function getDependencies() {
      return fileDependencies.slice();
    };
    loaderContext.getContextDependencies = function getContextDependencies() {
      return contextDependencies.slice();
    };
    loaderContext.getMissingDependencies = function getMissingDependencies() {
      return missingDependencies.slice();
    };
    loaderContext.clearDependencies = function clearDependencies() {
      fileDependencies.length = 0;
      contextDependencies.length = 0;
      missingDependencies.length = 0;
      requestCacheable = true;
    };
    Object.defineProperty(loaderContext, "resource", {
      enumerable: true,
      get: function() {
        if(loaderContext.resourcePath === undefined)
          return undefined;
        return loaderContext.resourcePath.replace(/#/g, "\0#") + loaderContext.resourceQuery.replace(/#/g, "\0#") + loaderContext.resourceFragment;
      },
      set: function(value) {
        var splittedResource = value && parsePathQueryFragment(value);
        loaderContext.resourcePath = splittedResource ? splittedResource.path : undefined;
        loaderContext.resourceQuery = splittedResource ? splittedResource.query : undefined;
        loaderContext.resourceFragment = splittedResource ? splittedResource.fragment : undefined;
      }
    });
    Object.defineProperty(loaderContext, "request", {
      enumerable: true,
      get: function() {
        return loaderContext.loaders.map(function(o) {
          return o.request;
        }).concat(loaderContext.resource || "").join("!");
      }
    });
    Object.defineProperty(loaderContext, "remainingRequest", {
      enumerable: true,
      get: function() {
        if(loaderContext.loaderIndex >= loaderContext.loaders.length - 1 && !loaderContext.resource)
          return "";
        return loaderContext.loaders.slice(loaderContext.loaderIndex + 1).map(function(o) {
          return o.request;
        }).concat(loaderContext.resource || "").join("!");
      }
    });
    Object.defineProperty(loaderContext, "currentRequest", {
      enumerable: true,
      get: function() {
        return loaderContext.loaders.slice(loaderContext.loaderIndex).map(function(o) {
          return o.request;
        }).concat(loaderContext.resource || "").join("!");
      }
    });
    Object.defineProperty(loaderContext, "previousRequest", {
      enumerable: true,
      get: function() {
        return loaderContext.loaders.slice(0, loaderContext.loaderIndex).map(function(o) {
          return o.request;
        }).join("!");
      }
    });
    Object.defineProperty(loaderContext, "query", {
      enumerable: true,
      get: function() {
        var entry = loaderContext.loaders[loaderContext.loaderIndex];
        return entry.options && typeof entry.options === "object" ? entry.options : entry.query;
      }
    });
    Object.defineProperty(loaderContext, "data", {
      enumerable: true,
      get: function() {
        return loaderContext.loaders[loaderContext.loaderIndex].data;
      }
    });

    // finish loader context
    if(Object.preventExtensions) {
      Object.preventExtensions(loaderContext);
    }

    var processOptions = {
      resourceBuffer: null,
      processResource: processResource
    };
    iteratePitchingLoaders(processOptions, loaderContext, function(err, result) {
      if(err) {
        return callback(err, {
          cacheable: requestCacheable,
          fileDependencies: fileDependencies,
          contextDependencies: contextDependencies,
          missingDependencies: missingDependencies
        });
      }
      callback(null, {
        result: result,
        resourceBuffer: processOptions.resourceBuffer,
        cacheable: requestCacheable,
        fileDependencies: fileDependencies,
        contextDependencies: contextDependencies,
        missingDependencies: missingDependencies
      });
    });
  };

  }();
  module.exports = __webpack_exports__;
  /******/ })()
  ;