{"version":3,"sources":["node_modules\\regenerator-runtime\\runtime.js"],"names":["global","Op","Object","prototype","hasOwn","hasOwnProperty","undefined","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","inModule","module","runtime","regeneratorRuntime","exports","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","create","context","Context","_invoke","makeInvokeMethod","tryCatch","fn","obj","arg","type","call","err","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","constructor","displayName","defineIteratorMethods","forEach","method","isGeneratorFunction","genFun","ctor","name","mark","setPrototypeOf","__proto__","awrap","__await","AsyncIterator","invoke","resolve","reject","record","result","value","Promise","then","unwrapped","process","domain","bind","previousPromise","enqueue","callInvokeWithMethodAndArg","async","iter","next","done","state","Error","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","return","TypeError","info","resultName","nextLoc","toString","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","keys","object","key","reverse","length","pop","iterable","iteratorMethod","isNaN","i","skipTempReset","prev","charAt","slice","stop","rootEntry","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","window"],"mappings":"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","file":"runtime.js","sourceRoot":"D:/Work/Office/react-native-on-web/cli/tmpl/project","sourcesContent":["/**\n * Copyright (c) 2014, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * https://raw.github.com/facebook/regenerator/master/LICENSE file. An\n * additional grant of patent rights can be found in the PATENTS file in\n * the same directory.\n */\n\n!(function(global) {\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  var inModule = typeof module === \"object\";\n  var runtime = global.regeneratorRuntime;\n  if (runtime) {\n    if (inModule) {\n      // If regeneratorRuntime is defined globally and we're in a module,\n      // make the exports object identical to regeneratorRuntime.\n      module.exports = runtime;\n    }\n    // Don't bother evaluating the rest of this file if the runtime was\n    // already defined globally.\n    return;\n  }\n\n  // Define the runtime globally (as expected by generated code) as either\n  // module.exports (if we're in a module) or a new, empty object.\n  runtime = global.regeneratorRuntime = inModule ? module.exports : {};\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  runtime.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  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\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      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  runtime.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  runtime.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\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  runtime.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\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 Promise.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 Promise.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. If the Promise is rejected, however, the\n          // result for this iteration will be rejected with the same\n          // reason. Note that rejections of yielded Promises are not\n          // thrown back into the generator function, as is the case\n          // when an awaited Promise is rejected. This difference in\n          // behavior between yield and await is important, because it\n          // allows the consumer to decide what to do with the yielded\n          // rejection (swallow it and continue, manually .throw it back\n          // into the generator, abandon iteration, whatever). With\n          // await, by contrast, there is no opportunity to examine the\n          // rejection reason outside the generator function, so the\n          // only option is to throw it from the await expression, and\n          // let the generator function handle the exception.\n          result.value = unwrapped;\n          resolve(result);\n        }, reject);\n      }\n    }\n\n    if (typeof global.process === \"object\" && global.process.domain) {\n      invoke = global.process.domain.bind(invoke);\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(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  runtime.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  runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return runtime.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        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  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  runtime.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  runtime.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  // Among the various tricks for obtaining a reference to the global\n  // object, this seems to be the most reliable technique that does not\n  // use indirect eval (which violates Content Security Policy).\n  typeof global === \"object\" ? global :\n  typeof window === \"object\" ? window :\n  typeof self === \"object\" ? self : this\n);\n"]}