{"version":3,"sources":["webpack://FFmpeg/webpack/universalModuleDefinition","webpack://FFmpeg/./src/browser/defaultOptions.js","webpack://FFmpeg/./src/browser/fetchFile.js","webpack://FFmpeg/./src/browser/getCreateFFmpegCore.js","webpack://FFmpeg/./src/browser/index.js","webpack://FFmpeg/./src/config.js","webpack://FFmpeg/./src/createFFmpeg.js","webpack://FFmpeg/./src/index.js","webpack://FFmpeg/./src/utils/log.js","webpack://FFmpeg/./src/utils/parseArgs.js","webpack://FFmpeg/./src/utils/parseProgress.js","webpack://FFmpeg/./node_modules/regenerator-runtime/runtime.js","webpack://FFmpeg/./node_modules/resolve-url/resolve-url.js","webpack://FFmpeg/webpack/bootstrap","webpack://FFmpeg/webpack/startup"],"names":["root","factory","exports","module","define","amd","self","require","devDependencies","corePath","substring","resolveURL","readFromBlobOrFile","blob","Promise","resolve","reject","fileReader","FileReader","onload","result","onerror","code","target","error","Error","readAsArrayBuffer","_data","data","Uint8Array","test","atob","split","map","c","charCodeAt","fetch","res","arrayBuffer","File","Blob","log","toBlobURL","url","mimeType","buf","byteLength","type","blobURL","URL","createObjectURL","_corePath","coreRemotePath","replace","wasmPath","workerPath","createFFmpegCore","script","document","createElement","src","addEventListener","eventHandler","removeEventListener","getElementsByTagName","appendChild","defaultOptions","getCreateFFmpegCore","fetchFile","defaultArgs","baseOptions","logger","progress","setLogging","setCustomLogger","parseProgress","parseArgs","version","NO_LOAD","_options","logging","optProgress","options","Core","ffmpeg","runResolve","running","detectCompletion","message","parseMessage","load","mainScriptUrlOrBlob","printErr","print","locateFile","path","prefix","window","endsWith","cwrap","isLoaded","run","_args","join","args","filter","s","length","FS","method","arg","ret","e","exit","setProgress","_progress","setLogger","_logger","createFFmpeg","customLogger","_logging","console","argsPtr","_malloc","Uint32Array","BYTES_PER_ELEMENT","forEach","idx","writeAsciiToMemory","setValue","duration","ratio","ts2sec","ts","h","m","parseFloat","startsWith","d","t","time","runtime","undefined","Op","Object","prototype","hasOwn","hasOwnProperty","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","obj","key","value","defineProperty","enumerable","configurable","writable","err","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","create","context","Context","_invoke","state","GenStateSuspendedStart","GenStateExecuting","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","done","GenStateSuspendedYield","makeInvokeMethod","fn","call","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","this","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","invoke","__await","then","unwrapped","previousPromise","callInvokeWithMethodAndArg","TypeError","info","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","i","constructor","displayName","isGeneratorFunction","genFun","ctor","name","mark","setPrototypeOf","__proto__","awrap","async","iter","toString","keys","object","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","numUrls","arguments","base","href","head","insertBefore","firstChild","resolved","a","index","removeChild","__webpack_module_cache__","__webpack_require__","moduleId","__webpack_modules__"],"mappings":"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","file":"ffmpeg.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"FFmpeg\"] = factory();\n\telse\n\t\troot[\"FFmpeg\"] = factory();\n})(self, function() {\nreturn ","const resolveURL = require('resolve-url');\nconst { devDependencies } = require('../../package.json');\n\n/*\n * Default options for browser environment\n */\nmodule.exports = {\n  corePath: process.env.NODE_ENV === 'development'\n    ? resolveURL('/node_modules/@ffmpeg/core/dist/ffmpeg-core.js')\n    : `https://unpkg.com/@ffmpeg/core@${devDependencies['@ffmpeg/core'].substring(1)}/dist/ffmpeg-core.js`,\n};\n","const resolveURL = require('resolve-url');\n\nconst readFromBlobOrFile = (blob) => (\n  new Promise((resolve, reject) => {\n    const fileReader = new FileReader();\n    fileReader.onload = () => {\n      resolve(fileReader.result);\n    };\n    fileReader.onerror = ({ target: { error: { code } } }) => {\n      reject(Error(`File could not be read! Code=${code}`));\n    };\n    fileReader.readAsArrayBuffer(blob);\n  })\n);\n\nmodule.exports = async (_data) => {\n  let data = _data;\n  if (typeof _data === 'undefined') {\n    return new Uint8Array();\n  }\n\n  if (typeof _data === 'string') {\n    /* From base64 format */\n    if (/data:_data\\/([a-zA-Z]*);base64,([^\"]*)/.test(_data)) {\n      data = atob(_data.split(',')[1])\n        .split('')\n        .map((c) => c.charCodeAt(0));\n    /* From remote server/URL */\n    } else {\n      const res = await fetch(resolveURL(_data));\n      data = await res.arrayBuffer();\n    }\n  /* From Blob or File */\n  } else if (_data instanceof File || _data instanceof Blob) {\n    data = await readFromBlobOrFile(_data);\n  }\n\n  return new Uint8Array(data);\n};\n","/* eslint-disable no-undef */\nconst resolveURL = require('resolve-url');\nconst { log } = require('../utils/log');\n\n/*\n * Fetch data from remote URL and convert to blob URL\n * to avoid CORS issue\n */\nconst toBlobURL = async (url, mimeType) => {\n  log('info', `fetch ${url}`);\n  const buf = await (await fetch(url)).arrayBuffer();\n  log('info', `${url} file size = ${buf.byteLength} bytes`);\n  const blob = new Blob([buf], { type: mimeType });\n  const blobURL = URL.createObjectURL(blob);\n  log('info', `${url} blob URL = ${blobURL}`);\n  return blobURL;\n};\n\nmodule.exports = async ({ corePath: _corePath }) => {\n  if (typeof _corePath !== 'string') {\n    throw Error('corePath should be a string!');\n  }\n  const coreRemotePath = resolveURL(_corePath);\n  const corePath = await toBlobURL(\n    coreRemotePath,\n    'application/javascript',\n  );\n  const wasmPath = await toBlobURL(\n    coreRemotePath.replace('ffmpeg-core.js', 'ffmpeg-core.wasm'),\n    'application/wasm',\n  );\n  const workerPath = await toBlobURL(\n    coreRemotePath.replace('ffmpeg-core.js', 'ffmpeg-core.worker.js'),\n    'application/javascript',\n  );\n  if (typeof createFFmpegCore === 'undefined') {\n    return new Promise((resolve) => {\n      const script = document.createElement('script');\n      const eventHandler = () => {\n        script.removeEventListener('load', eventHandler);\n        log('info', 'ffmpeg-core.js script loaded');\n        resolve({\n          createFFmpegCore,\n          corePath,\n          wasmPath,\n          workerPath,\n        });\n      };\n      script.src = corePath;\n      script.type = 'text/javascript';\n      script.addEventListener('load', eventHandler);\n      document.getElementsByTagName('head')[0].appendChild(script);\n    });\n  }\n  log('info', 'ffmpeg-core.js script is loaded already');\n  return Promise.resolve({\n    createFFmpegCore,\n    corePath,\n    wasmPath,\n    workerPath,\n  });\n};\n","const defaultOptions = require('./defaultOptions');\nconst getCreateFFmpegCore = require('./getCreateFFmpegCore');\nconst fetchFile = require('./fetchFile');\n\nmodule.exports = {\n  defaultOptions,\n  getCreateFFmpegCore,\n  fetchFile,\n};\n","module.exports = {\n  defaultArgs: [\n    /* args[0] is always the binary path */\n    './ffmpeg',\n    /* Disable interaction mode */\n    '-nostdin',\n    /* Force to override output file */\n    '-y',\n  ],\n  baseOptions: {\n    /* Flag to turn on/off log messages in console */\n    log: false,\n    /*\n     * Custom logger to get ffmpeg.wasm output messages.\n     * a sample logger looks like this:\n     *\n     * ```\n     * logger = ({ type, message }) => {\n     *   console.log(type, message);\n     * }\n     * ```\n     *\n     * type can be one of following:\n     *\n     * info: internal workflow debug messages\n     * fferr: ffmpeg native stderr output\n     * ffout: ffmpeg native stdout output\n     */\n    logger: () => {},\n    /*\n     * Progress handler to get current progress of ffmpeg command.\n     * a sample progress handler looks like this:\n     *\n     * ```\n     * progress = ({ ratio }) => {\n     *   console.log(ratio);\n     * }\n     * ```\n     *\n     * ratio is a float number between 0 to 1.\n     */\n    progress: () => {},\n    /*\n     * Path to find/download ffmpeg.wasm-core,\n     * this value should be overwriten by `defaultOptions` in\n     * each environment.\n     */\n    corePath: '',\n  },\n};\n","const { defaultArgs, baseOptions } = require('./config');\nconst { setLogging, setCustomLogger, log } = require('./utils/log');\nconst parseProgress = require('./utils/parseProgress');\nconst parseArgs = require('./utils/parseArgs');\nconst { defaultOptions, getCreateFFmpegCore } = require('./node');\nconst { version } = require('../package.json');\n\nconst NO_LOAD = Error('ffmpeg.wasm is not ready, make sure you have completed load().');\n\nmodule.exports = (_options = {}) => {\n  const {\n    log: logging,\n    logger,\n    progress: optProgress,\n    ...options\n  } = {\n    ...baseOptions,\n    ...defaultOptions,\n    ..._options,\n  };\n  let Core = null;\n  let ffmpeg = null;\n  let runResolve = null;\n  let running = false;\n  let progress = optProgress;\n  const detectCompletion = (message) => {\n    if (message === 'FFMPEG_END' && runResolve !== null) {\n      runResolve();\n      runResolve = null;\n      running = false;\n    }\n  };\n  const parseMessage = ({ type, message }) => {\n    log(type, message);\n    parseProgress(message, progress);\n    detectCompletion(message);\n  };\n\n  /*\n   * Load ffmpeg.wasm-core script.\n   * In browser environment, the ffmpeg.wasm-core script is fetch from\n   * CDN and can be assign to a local path by assigning `corePath`.\n   * In node environment, we use dynamic require and the default `corePath`\n   * is `$ffmpeg/core`.\n   *\n   * Typically the load() func might take few seconds to minutes to complete,\n   * better to do it as early as possible.\n   *\n   */\n  const load = async () => {\n    log('info', 'load ffmpeg-core');\n    if (Core === null) {\n      log('info', 'loading ffmpeg-core');\n      /*\n       * In node environment, all paths are undefined as there\n       * is no need to set them.\n       */\n      const {\n        createFFmpegCore,\n        corePath,\n        workerPath,\n        wasmPath,\n      } = await getCreateFFmpegCore(options);\n      Core = await createFFmpegCore({\n        /*\n         * Assign mainScriptUrlOrBlob fixes chrome extension web worker issue\n         * as there is no document.currentScript in the context of content_scripts\n         */\n        mainScriptUrlOrBlob: corePath,\n        printErr: (message) => parseMessage({ type: 'fferr', message }),\n        print: (message) => parseMessage({ type: 'ffout', message }),\n        /*\n         * locateFile overrides paths of files that is loaded by main script (ffmpeg-core.js).\n         * It is critical for browser environment and we override both wasm and worker paths\n         * as we are using blob URL instead of original URL to avoid cross origin issues.\n         */\n        locateFile: (path, prefix) => {\n          if (typeof window !== 'undefined') {\n            if (typeof wasmPath !== 'undefined'\n              && path.endsWith('ffmpeg-core.wasm')) {\n              return wasmPath;\n            }\n            if (typeof workerPath !== 'undefined'\n              && path.endsWith('ffmpeg-core.worker.js')) {\n              return workerPath;\n            }\n          }\n          return prefix + path;\n        },\n      });\n      ffmpeg = Core.cwrap('proxy_main', 'number', ['number', 'number']);\n      log('info', 'ffmpeg-core loaded');\n    } else {\n      throw Error('ffmpeg.wasm was loaded, you should not load it again, use ffmpeg.isLoaded() to check next time.');\n    }\n  };\n\n  /*\n   * Determine whether the Core is loaded.\n   */\n  const isLoaded = () => Core !== null;\n\n  /*\n   * Run ffmpeg command.\n   * This is the major function in ffmpeg.wasm, you can just imagine it\n   * as ffmpeg native cli and what you need to pass is the same.\n   *\n   * For example, you can convert native command below:\n   *\n   * ```\n   * $ ffmpeg -i video.avi -c:v libx264 video.mp4\n   * ```\n   *\n   * To\n   *\n   * ```\n   * await ffmpeg.run('-i', 'video.avi', '-c:v', 'libx264', 'video.mp4');\n   * ```\n   *\n   */\n  const run = (..._args) => {\n    log('info', `run ffmpeg command: ${_args.join(' ')}`);\n    if (Core === null) {\n      throw NO_LOAD;\n    } else if (running) {\n      throw Error('ffmpeg.wasm can only run one command at a time');\n    } else {\n      running = true;\n      return new Promise((resolve) => {\n        const args = [...defaultArgs, ..._args].filter((s) => s.length !== 0);\n        runResolve = resolve;\n        ffmpeg(...parseArgs(Core, args));\n      });\n    }\n  };\n\n  /*\n   * Run FS operations.\n   * For input/output file of ffmpeg.wasm, it is required to save them to MEMFS\n   * first so that ffmpeg.wasm is able to consume them. Here we rely on the FS\n   * methods provided by Emscripten.\n   *\n   * Common methods to use are:\n   * ffmpeg.FS('writeFile', 'video.avi', new Uint8Array(...)): writeFile writes\n   * data to MEMFS. You need to use Uint8Array for binary data.\n   * ffmpeg.FS('readFile', 'video.mp4'): readFile from MEMFS.\n   * ffmpeg.FS('unlink', 'video.map'): delete file from MEMFS.\n   *\n   * For more info, check https://emscripten.org/docs/api_reference/Filesystem-API.html\n   *\n   */\n  const FS = (method, ...args) => {\n    log('info', `run FS.${method} ${args.map((arg) => (typeof arg === 'string' ? arg : `<${arg.length} bytes binary file>`)).join(' ')}`);\n    if (Core === null) {\n      throw NO_LOAD;\n    } else {\n      let ret = null;\n      try {\n        ret = Core.FS[method](...args);\n      } catch (e) {\n        if (method === 'readdir') {\n          throw Error(`ffmpeg.FS('readdir', '${args[0]}') error. Check if the path exists, ex: ffmpeg.FS('readdir', '/')`);\n        } else if (method === 'readFile') {\n          throw Error(`ffmpeg.FS('readFile', '${args[0]}') error. Check if the path exists`);\n        } else {\n          throw Error('Oops, something went wrong in FS operation.');\n        }\n      }\n      return ret;\n    }\n  };\n\n  /**\n   * forcibly terminate the ffmpeg program.\n   */\n  const exit = () => {\n    if (Core === null) {\n      throw NO_LOAD;\n    } else {\n      running = false;\n      Core.exit(1);\n      Core = null;\n      ffmpeg = null;\n      runResolve = null;\n    }\n  };\n\n  const setProgress = (_progress) => {\n    progress = _progress;\n  };\n\n  const setLogger = (_logger) => {\n    setCustomLogger(_logger);\n  };\n\n  setLogging(logging);\n  setCustomLogger(logger);\n\n  log('info', `use ffmpeg.wasm v${version}`);\n\n  return {\n    setProgress,\n    setLogger,\n    setLogging,\n    load,\n    isLoaded,\n    run,\n    exit,\n    FS,\n  };\n};\n","require('regenerator-runtime/runtime');\nconst createFFmpeg = require('./createFFmpeg');\nconst { fetchFile } = require('./node');\n\nmodule.exports = {\n  /*\n   * Create ffmpeg instance.\n   * Each ffmpeg instance owns an isolated MEMFS and works\n   * independently.\n   *\n   * For example:\n   *\n   * ```\n   * const ffmpeg = createFFmpeg({\n   *  log: true,\n   *  logger: () => {},\n   *  progress: () => {},\n   *  corePath: '',\n   * })\n   * ```\n   *\n   * For the usage of these four arguments, check config.js\n   *\n   */\n  createFFmpeg,\n  /*\n   * Helper function for fetching files from various resource.\n   * Sometimes the video/audio file you want to process may located\n   * in a remote URL and somewhere in your local file system.\n   *\n   * This helper function helps you to fetch to file and return an\n   * Uint8Array variable for ffmpeg.wasm to consume.\n   *\n   */\n  fetchFile,\n};\n","let logging = false;\nlet customLogger = () => {};\n\nconst setLogging = (_logging) => {\n  logging = _logging;\n};\n\nconst setCustomLogger = (logger) => {\n  customLogger = logger;\n};\n\nconst log = (type, message) => {\n  customLogger({ type, message });\n  if (logging) {\n    console.log(`[${type}] ${message}`);\n  }\n};\n\nmodule.exports = {\n  logging,\n  setLogging,\n  setCustomLogger,\n  log,\n};\n","module.exports = (Core, args) => {\n  const argsPtr = Core._malloc(args.length * Uint32Array.BYTES_PER_ELEMENT);\n  args.forEach((s, idx) => {\n    const buf = Core._malloc(s.length + 1);\n    Core.writeAsciiToMemory(s, buf);\n    Core.setValue(argsPtr + (Uint32Array.BYTES_PER_ELEMENT * idx), buf, 'i32');\n  });\n  return [args.length, argsPtr];\n};\n","let duration = 0;\nlet ratio = 0;\n\nconst ts2sec = (ts) => {\n  const [h, m, s] = ts.split(':');\n  return (parseFloat(h) * 60 * 60) + (parseFloat(m) * 60) + parseFloat(s);\n};\n\nmodule.exports = (message, progress) => {\n  if (typeof message === 'string') {\n    if (message.startsWith('  Duration')) {\n      const ts = message.split(', ')[0].split(': ')[1];\n      const d = ts2sec(ts);\n      progress({ duration: d, ratio });\n      if (duration === 0 || duration > d) {\n        duration = d;\n      }\n    } else if (message.startsWith('frame') || message.startsWith('size')) {\n      const ts = message.split('time=')[1].split(' ')[0];\n      const t = ts2sec(ts);\n      ratio = t / duration;\n      progress({ ratio, time: t });\n    } else if (message.startsWith('video:')) {\n      progress({ ratio: 1 });\n      duration = 0;\n    }\n  }\n};\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","// Copyright 2014 Simon Lydell\r\n// X11 (“MIT”) Licensed. (See LICENSE.)\r\n\r\nvoid (function(root, factory) {\r\n  if (typeof define === \"function\" && define.amd) {\r\n    define(factory)\r\n  } else if (typeof exports === \"object\") {\r\n    module.exports = factory()\r\n  } else {\r\n    root.resolveUrl = factory()\r\n  }\r\n}(this, function() {\r\n\r\n  function resolveUrl(/* ...urls */) {\r\n    var numUrls = arguments.length\r\n\r\n    if (numUrls === 0) {\r\n      throw new Error(\"resolveUrl requires at least one argument; got none.\")\r\n    }\r\n\r\n    var base = document.createElement(\"base\")\r\n    base.href = arguments[0]\r\n\r\n    if (numUrls === 1) {\r\n      return base.href\r\n    }\r\n\r\n    var head = document.getElementsByTagName(\"head\")[0]\r\n    head.insertBefore(base, head.firstChild)\r\n\r\n    var a = document.createElement(\"a\")\r\n    var resolved\r\n\r\n    for (var index = 1; index < numUrls; index++) {\r\n      a.href = arguments[index]\r\n      resolved = a.href\r\n      base.href = resolved\r\n    }\r\n\r\n    head.removeChild(base)\r\n\r\n    return resolved\r\n  }\r\n\r\n  return resolveUrl\r\n\r\n}));\r\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tif(__webpack_module_cache__[moduleId]) {\n\t\treturn __webpack_module_cache__[moduleId].exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// module exports must be returned from runtime so entry inlining is disabled\n// startup\n// Load entry module and return exports\nreturn __webpack_require__(352);\n"],"sourceRoot":""}