{"version":3,"sources":["webpack:///./node_modules/get-blob-duration/dist/getBlobDuration.js","webpack:///./node_modules/get-blob-duration/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:///./node_modules/get-blob-duration/node_modules/@babel/runtime/regenerator/index.js","webpack:///./node_modules/capacitor-voice-recorder/dist/esm/predefined-web-responses.js","webpack:///./node_modules/capacitor-voice-recorder/dist/esm/VoiceRecorderImpl.js","webpack:///./node_modules/capacitor-voice-recorder/dist/esm/web.js","webpack:///./node_modules/get-blob-duration/node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack:///./node_modules/get-blob-duration/node_modules/regenerator-runtime/runtime.js"],"names":["_interopRequireDefault","Object","defineProperty","exports","value","default","getBlobDuration","_regenerator","_asyncToGenerator2","e","_getBlobDuration","apply","this","arguments","mark","r","t","n","wrap","prev","next","document","createElement","Promise","addEventListener","duration","currentTime","Number","MAX_SAFE_INTEGER","ontimeupdate","onerror","target","error","src","String","window","URL","createObjectURL","abrupt","stop","asyncGeneratorStep","gen","resolve","reject","_next","_throw","key","arg","info","done","then","_asyncToGenerator","fn","self","args","err","undefined","module","require","successResponse","failureResponse","missingPermissionError","Error","alreadyRecordingError","deviceCannotVoiceRecordError","failedToRecordError","emptyRecordingError","recordingHasNotStartedError","failedToFetchRecordingError","couldNotQueryPermissionStatusError","possibleMimeTypes","neverResolvingPromise","mediaRecorder","chunks","pendingResult","_a","navigator","mediaDevices","getUserMedia","getSupportedMimeType","deviceCanRecord","canDeviceVoiceRecord","havingPermission","hasAudioRecordingPermission","catch","audio","onSuccessfullyStartedRecording","bind","onFailedToStartRecording","stream","getTracks","forEach","track","ignore","prepareInstanceForNextOperation","permissions","query","name","result","state","pause","resume","status","MediaRecorder","isTypeSupported","foundSupportedType","find","type","onstop","async","mimeType","blobVoiceRecording","Blob","size","recordDataBase64","blobToBase64","recordingDuration","msDuration","ondataavailable","event","push","data","start","blob","reader","FileReader","onloadend","recordingResult","splitResult","split","toResolve","length","trim","readAsDataURL","super","voiceRecorderInstance","requestAudioRecordingPermission","startRecording","stopRecording","pauseRecording","resumeRecording","getCurrentStatus","obj","__esModule","runtime","Op","prototype","hasOwn","hasOwnProperty","desc","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","enumerable","configurable","writable","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","create","context","Context","makeInvokeMethod","tryCatch","call","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","method","_invoke","AsyncIterator","PromiseImpl","invoke","record","__await","unwrapped","previousPromise","enqueue","callInvokeWithMethodAndArg","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","methodName","TypeError","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","i","displayName","isGeneratorFunction","genFun","ctor","constructor","setPrototypeOf","__proto__","awrap","iter","keys","val","object","reverse","pop","skipTempReset","charAt","slice","rootEntry","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","globalThis","Function"],"mappings":"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","file":"js/chunk-b5da73e8.bf51e62f.js","sourcesContent":["\"use strict\";var _interopRequireDefault=require(\"@babel/runtime/helpers/interopRequireDefault\");Object.defineProperty(exports,\"__esModule\",{value:!0}),exports.default=getBlobDuration;var _regenerator=_interopRequireDefault(require(\"@babel/runtime/regenerator\")),_asyncToGenerator2=_interopRequireDefault(require(\"@babel/runtime/helpers/asyncToGenerator\"));function getBlobDuration(e){return _getBlobDuration.apply(this,arguments)}function _getBlobDuration(){return(_getBlobDuration=(0,_asyncToGenerator2.default)(_regenerator.default.mark(function e(r){var t,n;return _regenerator.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return t=document.createElement(\"video\"),n=new Promise(function(e,r){t.addEventListener(\"loadedmetadata\",function(){t.duration===1/0?(t.currentTime=Number.MAX_SAFE_INTEGER,t.ontimeupdate=function(){t.ontimeupdate=null,e(t.duration),t.currentTime=0}):e(t.duration)}),t.onerror=function(e){return r(e.target.error)}}),t.src=\"string\"==typeof r||r instanceof String?r:window.URL.createObjectURL(r),e.abrupt(\"return\",n);case 4:case\"end\":return e.stop()}},e)}))).apply(this,arguments)}\n//# sourceMappingURL=getBlobDuration.js.map\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;","module.exports = require(\"regenerator-runtime\");\n","export const successResponse = () => ({ value: true });\nexport const failureResponse = () => ({ value: false });\nexport const missingPermissionError = () => new Error('MISSING_PERMISSION');\nexport const alreadyRecordingError = () => new Error('ALREADY_RECORDING');\nexport const microphoneBeingUsedError = () => new Error('MICROPHONE_BEING_USED');\nexport const deviceCannotVoiceRecordError = () => new Error('DEVICE_CANNOT_VOICE_RECORD');\nexport const failedToRecordError = () => new Error('FAILED_TO_RECORD');\nexport const emptyRecordingError = () => new Error('EMPTY_RECORDING');\nexport const recordingHasNotStartedError = () => new Error('RECORDING_HAS_NOT_STARTED');\nexport const failedToFetchRecordingError = () => new Error('FAILED_TO_FETCH_RECORDING');\nexport const couldNotQueryPermissionStatusError = () => new Error('COULD_NOT_QUERY_PERMISSION_STATUS');\n//# sourceMappingURL=predefined-web-responses.js.map","import getBlobDuration from 'get-blob-duration';\nimport { alreadyRecordingError, couldNotQueryPermissionStatusError, deviceCannotVoiceRecordError, emptyRecordingError, failedToFetchRecordingError, failedToRecordError, failureResponse, missingPermissionError, recordingHasNotStartedError, successResponse, } from './predefined-web-responses';\n// these mime types will be checked one by one in order until one of them is found to be supported by the current browser\nconst possibleMimeTypes = ['audio/aac', 'audio/webm;codecs=opus', 'audio/mp4', 'audio/webm', 'audio/ogg;codecs=opus'];\nconst neverResolvingPromise = () => new Promise(() => undefined);\nexport class VoiceRecorderImpl {\n    constructor() {\n        this.mediaRecorder = null;\n        this.chunks = [];\n        this.pendingResult = neverResolvingPromise();\n    }\n    static async canDeviceVoiceRecord() {\n        var _a;\n        if (((_a = navigator === null || navigator === void 0 ? void 0 : navigator.mediaDevices) === null || _a === void 0 ? void 0 : _a.getUserMedia) == null || VoiceRecorderImpl.getSupportedMimeType() == null) {\n            return failureResponse();\n        }\n        else {\n            return successResponse();\n        }\n    }\n    async startRecording() {\n        if (this.mediaRecorder != null) {\n            throw alreadyRecordingError();\n        }\n        const deviceCanRecord = await VoiceRecorderImpl.canDeviceVoiceRecord();\n        if (!deviceCanRecord.value) {\n            throw deviceCannotVoiceRecordError();\n        }\n        const havingPermission = await VoiceRecorderImpl.hasAudioRecordingPermission().catch(() => successResponse());\n        if (!havingPermission.value) {\n            throw missingPermissionError();\n        }\n        navigator.mediaDevices.getUserMedia({ audio: true })\n            .then(this.onSuccessfullyStartedRecording.bind(this))\n            .catch(this.onFailedToStartRecording.bind(this));\n        return successResponse();\n    }\n    async stopRecording() {\n        if (this.mediaRecorder == null) {\n            throw recordingHasNotStartedError();\n        }\n        try {\n            this.mediaRecorder.stop();\n            this.mediaRecorder.stream.getTracks().forEach(track => track.stop());\n            return this.pendingResult;\n        }\n        catch (ignore) {\n            throw failedToFetchRecordingError();\n        }\n        finally {\n            this.prepareInstanceForNextOperation();\n        }\n    }\n    static async hasAudioRecordingPermission() {\n        return navigator.permissions.query({ name: 'microphone' })\n            .then(result => ({ value: result.state === 'granted' }))\n            .catch(() => {\n            throw couldNotQueryPermissionStatusError();\n        });\n    }\n    static async requestAudioRecordingPermission() {\n        const havingPermission = await VoiceRecorderImpl.hasAudioRecordingPermission().catch(() => failureResponse());\n        if (havingPermission.value) {\n            return successResponse();\n        }\n        return navigator.mediaDevices.getUserMedia({ audio: true })\n            .then(() => successResponse())\n            .catch(() => failureResponse());\n    }\n    pauseRecording() {\n        if (this.mediaRecorder == null) {\n            throw recordingHasNotStartedError();\n        }\n        else if (this.mediaRecorder.state === 'recording') {\n            this.mediaRecorder.pause();\n            return Promise.resolve(successResponse());\n        }\n        else {\n            return Promise.resolve(failureResponse());\n        }\n    }\n    resumeRecording() {\n        if (this.mediaRecorder == null) {\n            throw recordingHasNotStartedError();\n        }\n        else if (this.mediaRecorder.state === 'paused') {\n            this.mediaRecorder.resume();\n            return Promise.resolve(successResponse());\n        }\n        else {\n            return Promise.resolve(failureResponse());\n        }\n    }\n    getCurrentStatus() {\n        if (this.mediaRecorder == null) {\n            return Promise.resolve({ status: 'NONE' });\n        }\n        else if (this.mediaRecorder.state === 'recording') {\n            return Promise.resolve({ status: 'RECORDING' });\n        }\n        else if (this.mediaRecorder.state === 'paused') {\n            return Promise.resolve({ status: 'PAUSED' });\n        }\n        else {\n            return Promise.resolve({ status: 'NONE' });\n        }\n    }\n    static getSupportedMimeType() {\n        if ((MediaRecorder === null || MediaRecorder === void 0 ? void 0 : MediaRecorder.isTypeSupported) == null)\n            return null;\n        const foundSupportedType = possibleMimeTypes.find(type => MediaRecorder.isTypeSupported(type));\n        return foundSupportedType !== null && foundSupportedType !== void 0 ? foundSupportedType : null;\n    }\n    onSuccessfullyStartedRecording(stream) {\n        this.pendingResult = new Promise((resolve, reject) => {\n            this.mediaRecorder = new MediaRecorder(stream);\n            this.mediaRecorder.onerror = () => {\n                this.prepareInstanceForNextOperation();\n                reject(failedToRecordError());\n            };\n            this.mediaRecorder.onstop = async () => {\n                const mimeType = VoiceRecorderImpl.getSupportedMimeType();\n                if (mimeType == null) {\n                    this.prepareInstanceForNextOperation();\n                    reject(failedToFetchRecordingError());\n                    return;\n                }\n                const blobVoiceRecording = new Blob(this.chunks, { 'type': mimeType });\n                if (blobVoiceRecording.size <= 0) {\n                    this.prepareInstanceForNextOperation();\n                    reject(emptyRecordingError());\n                    return;\n                }\n                const recordDataBase64 = await VoiceRecorderImpl.blobToBase64(blobVoiceRecording);\n                const recordingDuration = await getBlobDuration(blobVoiceRecording);\n                this.prepareInstanceForNextOperation();\n                resolve({ value: { recordDataBase64, mimeType, msDuration: recordingDuration * 1000 } });\n            };\n            this.mediaRecorder.ondataavailable = (event) => this.chunks.push(event.data);\n            this.mediaRecorder.start();\n        });\n    }\n    onFailedToStartRecording() {\n        this.prepareInstanceForNextOperation();\n        throw failedToRecordError();\n    }\n    static blobToBase64(blob) {\n        return new Promise(resolve => {\n            const reader = new FileReader();\n            reader.onloadend = () => {\n                const recordingResult = String(reader.result);\n                const splitResult = recordingResult.split('base64,');\n                const toResolve = (splitResult.length > 1) ? splitResult[1] : recordingResult;\n                resolve(toResolve.trim());\n            };\n            reader.readAsDataURL(blob);\n        });\n    }\n    prepareInstanceForNextOperation() {\n        if (this.mediaRecorder != null && this.mediaRecorder.state === 'recording') {\n            try {\n                this.mediaRecorder.stop();\n            }\n            catch (ignore) {\n            }\n        }\n        this.pendingResult = neverResolvingPromise();\n        this.mediaRecorder = null;\n        this.chunks = [];\n    }\n}\n//# sourceMappingURL=VoiceRecorderImpl.js.map","import { WebPlugin } from '@capacitor/core';\nimport { VoiceRecorderImpl } from './VoiceRecorderImpl';\nexport class VoiceRecorderWeb extends WebPlugin {\n    constructor() {\n        super(...arguments);\n        this.voiceRecorderInstance = new VoiceRecorderImpl();\n    }\n    canDeviceVoiceRecord() {\n        return VoiceRecorderImpl.canDeviceVoiceRecord();\n    }\n    hasAudioRecordingPermission() {\n        return VoiceRecorderImpl.hasAudioRecordingPermission();\n    }\n    requestAudioRecordingPermission() {\n        return VoiceRecorderImpl.requestAudioRecordingPermission();\n    }\n    startRecording() {\n        return this.voiceRecorderInstance.startRecording();\n    }\n    stopRecording() {\n        return this.voiceRecorderInstance.stopRecording();\n    }\n    pauseRecording() {\n        return this.voiceRecorderInstance.pauseRecording();\n    }\n    resumeRecording() {\n        return this.voiceRecorderInstance.resumeRecording();\n    }\n    getCurrentStatus() {\n        return this.voiceRecorderInstance.getCurrentStatus();\n    }\n}\n//# sourceMappingURL=web.js.map","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault;","/**\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 defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; };\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    defineProperty(generator, \"_invoke\", { value: 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  define(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 = GeneratorFunctionPrototype;\n  defineProperty(Gp, \"constructor\", { value: GeneratorFunctionPrototype, configurable: true });\n  defineProperty(\n    GeneratorFunctionPrototype,\n    \"constructor\",\n    { value: GeneratorFunction, configurable: true }\n  );\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    defineProperty(this, \"_invoke\", { value: enqueue });\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  define(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 methodName = context.method;\n    var method = delegate.iterator[methodName];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method, or a missing .next mehtod, always terminate the\n      // yield* loop.\n      context.delegate = null;\n\n      // Note: [\"return\"] must be used for ES3 parsing compatibility.\n      if (methodName === \"throw\" && 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      if (methodName !== \"return\") {\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a '\" + methodName + \"' 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  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(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(val) {\n    var object = Object(val);\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, in modern engines\n  // we can explicitly access globalThis. In older engines 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  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n"],"sourceRoot":""}