share-light 1.0.0 → 1.0.2

package/lib/index.js

@@ -4,6 +4,2521 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.shareLightSDK = {}));
 })(this, (function (exports) { 'use strict';
 
+  var libExports = {};
+  var lib = {
+    get exports(){ return libExports; },
+    set exports(v){ libExports = v; },
+  };
+
+  var qqShareExports = {};
+  var qqShare = {
+    get exports(){ return qqShareExports; },
+    set exports(v){ qqShareExports = v; },
+  };
+
+  var regeneratorExports = {};
+  var regenerator = {
+    get exports(){ return regeneratorExports; },
+    set exports(v){ regeneratorExports = v; },
+  };
+
+  var runtimeModuleExports = {};
+  var runtimeModule = {
+    get exports(){ return runtimeModuleExports; },
+    set exports(v){ runtimeModuleExports = v; },
+  };
+
+  var runtimeExports = {};
+  var runtime = {
+    get exports(){ return runtimeExports; },
+    set exports(v){ runtimeExports = v; },
+  };
+
+  /**
+   * Copyright (c) 2014-present, Facebook, Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+  (function (module) {
+  	!(function(global) {
+
+  	  var Op = Object.prototype;
+  	  var hasOwn = Op.hasOwnProperty;
+  	  var undefined$1; // More compressible than void 0.
+  	  var $Symbol = typeof Symbol === "function" ? Symbol : {};
+  	  var iteratorSymbol = $Symbol.iterator || "@@iterator";
+  	  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+  	  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+  	  var runtime = global.regeneratorRuntime;
+  	  if (runtime) {
+  	    {
+  	      // If regeneratorRuntime is defined globally and we're in a module,
+  	      // make the exports object identical to regeneratorRuntime.
+  	      module.exports = runtime;
+  	    }
+  	    // Don't bother evaluating the rest of this file if the runtime was
+  	    // already defined globally.
+  	    return;
+  	  }
+
+  	  // Define the runtime globally (as expected by generated code) as either
+  	  // module.exports (if we're in a module) or a new, empty object.
+  	  runtime = global.regeneratorRuntime = module.exports ;
+
+  	  function wrap(innerFn, outerFn, self, tryLocsList) {
+  	    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+  	    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+  	    var generator = Object.create(protoGenerator.prototype);
+  	    var context = new Context(tryLocsList || []);
+
+  	    // The ._invoke method unifies the implementations of the .next,
+  	    // .throw, and .return methods.
+  	    generator._invoke = makeInvokeMethod(innerFn, self, context);
+
+  	    return generator;
+  	  }
+  	  runtime.wrap = wrap;
+
+  	  // Try/catch helper to minimize deoptimizations. Returns a completion
+  	  // record like context.tryEntries[i].completion. This interface could
+  	  // have been (and was previously) designed to take a closure to be
+  	  // invoked without arguments, but in all the cases we care about we
+  	  // already have an existing method we want to call, so there's no need
+  	  // to create a new function object. We can even get away with assuming
+  	  // the method takes exactly one argument, since that happens to be true
+  	  // in every case, so we don't have to touch the arguments object. The
+  	  // only additional allocation required is the completion record, which
+  	  // has a stable shape and so hopefully should be cheap to allocate.
+  	  function tryCatch(fn, obj, arg) {
+  	    try {
+  	      return { type: "normal", arg: fn.call(obj, arg) };
+  	    } catch (err) {
+  	      return { type: "throw", arg: err };
+  	    }
+  	  }
+
+  	  var GenStateSuspendedStart = "suspendedStart";
+  	  var GenStateSuspendedYield = "suspendedYield";
+  	  var GenStateExecuting = "executing";
+  	  var GenStateCompleted = "completed";
+
+  	  // Returning this object from the innerFn has the same effect as
+  	  // breaking out of the dispatch switch statement.
+  	  var ContinueSentinel = {};
+
+  	  // Dummy constructor functions that we use as the .constructor and
+  	  // .constructor.prototype properties for functions that return Generator
+  	  // objects. For full spec compliance, you may wish to configure your
+  	  // minifier not to mangle the names of these two functions.
+  	  function Generator() {}
+  	  function GeneratorFunction() {}
+  	  function GeneratorFunctionPrototype() {}
+
+  	  // This is a polyfill for %IteratorPrototype% for environments that
+  	  // don't natively support it.
+  	  var IteratorPrototype = {};
+  	  IteratorPrototype[iteratorSymbol] = function () {
+  	    return this;
+  	  };
+
+  	  var getProto = Object.getPrototypeOf;
+  	  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  	  if (NativeIteratorPrototype &&
+  	      NativeIteratorPrototype !== Op &&
+  	      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+  	    // This environment has a native %IteratorPrototype%; use it instead
+  	    // of the polyfill.
+  	    IteratorPrototype = NativeIteratorPrototype;
+  	  }
+
+  	  var Gp = GeneratorFunctionPrototype.prototype =
+  	    Generator.prototype = Object.create(IteratorPrototype);
+  	  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+  	  GeneratorFunctionPrototype.constructor = GeneratorFunction;
+  	  GeneratorFunctionPrototype[toStringTagSymbol] =
+  	    GeneratorFunction.displayName = "GeneratorFunction";
+
+  	  // Helper for defining the .next, .throw, and .return methods of the
+  	  // Iterator interface in terms of a single ._invoke method.
+  	  function defineIteratorMethods(prototype) {
+  	    ["next", "throw", "return"].forEach(function(method) {
+  	      prototype[method] = function(arg) {
+  	        return this._invoke(method, arg);
+  	      };
+  	    });
+  	  }
+
+  	  runtime.isGeneratorFunction = function(genFun) {
+  	    var ctor = typeof genFun === "function" && genFun.constructor;
+  	    return ctor
+  	      ? ctor === GeneratorFunction ||
+  	        // For the native GeneratorFunction constructor, the best we can
+  	        // do is to check its .name property.
+  	        (ctor.displayName || ctor.name) === "GeneratorFunction"
+  	      : false;
+  	  };
+
+  	  runtime.mark = function(genFun) {
+  	    if (Object.setPrototypeOf) {
+  	      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+  	    } else {
+  	      genFun.__proto__ = GeneratorFunctionPrototype;
+  	      if (!(toStringTagSymbol in genFun)) {
+  	        genFun[toStringTagSymbol] = "GeneratorFunction";
+  	      }
+  	    }
+  	    genFun.prototype = Object.create(Gp);
+  	    return genFun;
+  	  };
+
+  	  // Within the body of any async function, `await x` is transformed to
+  	  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+  	  // `hasOwn.call(value, "__await")` to determine if the yielded value is
+  	  // meant to be awaited.
+  	  runtime.awrap = function(arg) {
+  	    return { __await: arg };
+  	  };
+
+  	  function AsyncIterator(generator) {
+  	    function invoke(method, arg, resolve, reject) {
+  	      var record = tryCatch(generator[method], generator, arg);
+  	      if (record.type === "throw") {
+  	        reject(record.arg);
+  	      } else {
+  	        var result = record.arg;
+  	        var value = result.value;
+  	        if (value &&
+  	            typeof value === "object" &&
+  	            hasOwn.call(value, "__await")) {
+  	          return Promise.resolve(value.__await).then(function(value) {
+  	            invoke("next", value, resolve, reject);
+  	          }, function(err) {
+  	            invoke("throw", err, resolve, reject);
+  	          });
+  	        }
+
+  	        return Promise.resolve(value).then(function(unwrapped) {
+  	          // When a yielded Promise is resolved, its final value becomes
+  	          // the .value of the Promise<{value,done}> result for the
+  	          // current iteration. If the Promise is rejected, however, the
+  	          // result for this iteration will be rejected with the same
+  	          // reason. Note that rejections of yielded Promises are not
+  	          // thrown back into the generator function, as is the case
+  	          // when an awaited Promise is rejected. This difference in
+  	          // behavior between yield and await is important, because it
+  	          // allows the consumer to decide what to do with the yielded
+  	          // rejection (swallow it and continue, manually .throw it back
+  	          // into the generator, abandon iteration, whatever). With
+  	          // await, by contrast, there is no opportunity to examine the
+  	          // rejection reason outside the generator function, so the
+  	          // only option is to throw it from the await expression, and
+  	          // let the generator function handle the exception.
+  	          result.value = unwrapped;
+  	          resolve(result);
+  	        }, reject);
+  	      }
+  	    }
+
+  	    var previousPromise;
+
+  	    function enqueue(method, arg) {
+  	      function callInvokeWithMethodAndArg() {
+  	        return new Promise(function(resolve, reject) {
+  	          invoke(method, arg, resolve, reject);
+  	        });
+  	      }
+
+  	      return previousPromise =
+  	        // If enqueue has been called before, then we want to wait until
+  	        // all previous Promises have been resolved before calling invoke,
+  	        // so that results are always delivered in the correct order. If
+  	        // enqueue has not been called before, then it is important to
+  	        // call invoke immediately, without waiting on a callback to fire,
+  	        // so that the async generator function has the opportunity to do
+  	        // any necessary setup in a predictable way. This predictability
+  	        // is why the Promise constructor synchronously invokes its
+  	        // executor callback, and why async functions synchronously
+  	        // execute code before the first await. Since we implement simple
+  	        // async functions in terms of async generators, it is especially
+  	        // important to get this right, even though it requires care.
+  	        previousPromise ? previousPromise.then(
+  	          callInvokeWithMethodAndArg,
+  	          // Avoid propagating failures to Promises returned by later
+  	          // invocations of the iterator.
+  	          callInvokeWithMethodAndArg
+  	        ) : callInvokeWithMethodAndArg();
+  	    }
+
+  	    // Define the unified helper method that is used to implement .next,
+  	    // .throw, and .return (see defineIteratorMethods).
+  	    this._invoke = enqueue;
+  	  }
+
+  	  defineIteratorMethods(AsyncIterator.prototype);
+  	  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+  	    return this;
+  	  };
+  	  runtime.AsyncIterator = AsyncIterator;
+
+  	  // Note that simple async functions are implemented on top of
+  	  // AsyncIterator objects; they just return a Promise for the value of
+  	  // the final result produced by the iterator.
+  	  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
+  	    var iter = new AsyncIterator(
+  	      wrap(innerFn, outerFn, self, tryLocsList)
+  	    );
+
+  	    return runtime.isGeneratorFunction(outerFn)
+  	      ? iter // If outerFn is a generator, return the full iterator.
+  	      : iter.next().then(function(result) {
+  	          return result.done ? result.value : iter.next();
+  	        });
+  	  };
+
+  	  function makeInvokeMethod(innerFn, self, context) {
+  	    var state = GenStateSuspendedStart;
+
+  	    return function invoke(method, arg) {
+  	      if (state === GenStateExecuting) {
+  	        throw new Error("Generator is already running");
+  	      }
+
+  	      if (state === GenStateCompleted) {
+  	        if (method === "throw") {
+  	          throw arg;
+  	        }
+
+  	        // Be forgiving, per 25.3.3.3.3 of the spec:
+  	        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+  	        return doneResult();
+  	      }
+
+  	      context.method = method;
+  	      context.arg = arg;
+
+  	      while (true) {
+  	        var delegate = context.delegate;
+  	        if (delegate) {
+  	          var delegateResult = maybeInvokeDelegate(delegate, context);
+  	          if (delegateResult) {
+  	            if (delegateResult === ContinueSentinel) continue;
+  	            return delegateResult;
+  	          }
+  	        }
+
+  	        if (context.method === "next") {
+  	          // Setting context._sent for legacy support of Babel's
+  	          // function.sent implementation.
+  	          context.sent = context._sent = context.arg;
+
+  	        } else if (context.method === "throw") {
+  	          if (state === GenStateSuspendedStart) {
+  	            state = GenStateCompleted;
+  	            throw context.arg;
+  	          }
+
+  	          context.dispatchException(context.arg);
+
+  	        } else if (context.method === "return") {
+  	          context.abrupt("return", context.arg);
+  	        }
+
+  	        state = GenStateExecuting;
+
+  	        var record = tryCatch(innerFn, self, context);
+  	        if (record.type === "normal") {
+  	          // If an exception is thrown from innerFn, we leave state ===
+  	          // GenStateExecuting and loop back for another invocation.
+  	          state = context.done
+  	            ? GenStateCompleted
+  	            : GenStateSuspendedYield;
+
+  	          if (record.arg === ContinueSentinel) {
+  	            continue;
+  	          }
+
+  	          return {
+  	            value: record.arg,
+  	            done: context.done
+  	          };
+
+  	        } else if (record.type === "throw") {
+  	          state = GenStateCompleted;
+  	          // Dispatch the exception by looping back around to the
+  	          // context.dispatchException(context.arg) call above.
+  	          context.method = "throw";
+  	          context.arg = record.arg;
+  	        }
+  	      }
+  	    };
+  	  }
+
+  	  // Call delegate.iterator[context.method](context.arg) and handle the
+  	  // result, either by returning a { value, done } result from the
+  	  // delegate iterator, or by modifying context.method and context.arg,
+  	  // setting context.delegate to null, and returning the ContinueSentinel.
+  	  function maybeInvokeDelegate(delegate, context) {
+  	    var method = delegate.iterator[context.method];
+  	    if (method === undefined$1) {
+  	      // A .throw or .return when the delegate iterator has no .throw
+  	      // method always terminates the yield* loop.
+  	      context.delegate = null;
+
+  	      if (context.method === "throw") {
+  	        if (delegate.iterator.return) {
+  	          // If the delegate iterator has a return method, give it a
+  	          // chance to clean up.
+  	          context.method = "return";
+  	          context.arg = undefined$1;
+  	          maybeInvokeDelegate(delegate, context);
+
+  	          if (context.method === "throw") {
+  	            // If maybeInvokeDelegate(context) changed context.method from
+  	            // "return" to "throw", let that override the TypeError below.
+  	            return ContinueSentinel;
+  	          }
+  	        }
+
+  	        context.method = "throw";
+  	        context.arg = new TypeError(
+  	          "The iterator does not provide a 'throw' method");
+  	      }
+
+  	      return ContinueSentinel;
+  	    }
+
+  	    var record = tryCatch(method, delegate.iterator, context.arg);
+
+  	    if (record.type === "throw") {
+  	      context.method = "throw";
+  	      context.arg = record.arg;
+  	      context.delegate = null;
+  	      return ContinueSentinel;
+  	    }
+
+  	    var info = record.arg;
+
+  	    if (! info) {
+  	      context.method = "throw";
+  	      context.arg = new TypeError("iterator result is not an object");
+  	      context.delegate = null;
+  	      return ContinueSentinel;
+  	    }
+
+  	    if (info.done) {
+  	      // Assign the result of the finished delegate to the temporary
+  	      // variable specified by delegate.resultName (see delegateYield).
+  	      context[delegate.resultName] = info.value;
+
+  	      // Resume execution at the desired location (see delegateYield).
+  	      context.next = delegate.nextLoc;
+
+  	      // If context.method was "throw" but the delegate handled the
+  	      // exception, let the outer generator proceed normally. If
+  	      // context.method was "next", forget context.arg since it has been
+  	      // "consumed" by the delegate iterator. If context.method was
+  	      // "return", allow the original .return call to continue in the
+  	      // outer generator.
+  	      if (context.method !== "return") {
+  	        context.method = "next";
+  	        context.arg = undefined$1;
+  	      }
+
+  	    } else {
+  	      // Re-yield the result returned by the delegate method.
+  	      return info;
+  	    }
+
+  	    // The delegate iterator is finished, so forget it and continue with
+  	    // the outer generator.
+  	    context.delegate = null;
+  	    return ContinueSentinel;
+  	  }
+
+  	  // Define Generator.prototype.{next,throw,return} in terms of the
+  	  // unified ._invoke helper method.
+  	  defineIteratorMethods(Gp);
+
+  	  Gp[toStringTagSymbol] = "Generator";
+
+  	  // A Generator should always return itself as the iterator object when the
+  	  // @@iterator function is called on it. Some browsers' implementations of the
+  	  // iterator prototype chain incorrectly implement this, causing the Generator
+  	  // object to not be returned from this call. This ensures that doesn't happen.
+  	  // See https://github.com/facebook/regenerator/issues/274 for more details.
+  	  Gp[iteratorSymbol] = function() {
+  	    return this;
+  	  };
+
+  	  Gp.toString = function() {
+  	    return "[object Generator]";
+  	  };
+
+  	  function pushTryEntry(locs) {
+  	    var entry = { tryLoc: locs[0] };
+
+  	    if (1 in locs) {
+  	      entry.catchLoc = locs[1];
+  	    }
+
+  	    if (2 in locs) {
+  	      entry.finallyLoc = locs[2];
+  	      entry.afterLoc = locs[3];
+  	    }
+
+  	    this.tryEntries.push(entry);
+  	  }
+
+  	  function resetTryEntry(entry) {
+  	    var record = entry.completion || {};
+  	    record.type = "normal";
+  	    delete record.arg;
+  	    entry.completion = record;
+  	  }
+
+  	  function Context(tryLocsList) {
+  	    // The root entry object (effectively a try statement without a catch
+  	    // or a finally block) gives us a place to store values thrown from
+  	    // locations where there is no enclosing try statement.
+  	    this.tryEntries = [{ tryLoc: "root" }];
+  	    tryLocsList.forEach(pushTryEntry, this);
+  	    this.reset(true);
+  	  }
+
+  	  runtime.keys = function(object) {
+  	    var keys = [];
+  	    for (var key in object) {
+  	      keys.push(key);
+  	    }
+  	    keys.reverse();
+
+  	    // Rather than returning an object with a next method, we keep
+  	    // things simple and return the next function itself.
+  	    return function next() {
+  	      while (keys.length) {
+  	        var key = keys.pop();
+  	        if (key in object) {
+  	          next.value = key;
+  	          next.done = false;
+  	          return next;
+  	        }
+  	      }
+
+  	      // To avoid creating an additional object, we just hang the .value
+  	      // and .done properties off the next function object itself. This
+  	      // also ensures that the minifier will not anonymize the function.
+  	      next.done = true;
+  	      return next;
+  	    };
+  	  };
+
+  	  function values(iterable) {
+  	    if (iterable) {
+  	      var iteratorMethod = iterable[iteratorSymbol];
+  	      if (iteratorMethod) {
+  	        return iteratorMethod.call(iterable);
+  	      }
+
+  	      if (typeof iterable.next === "function") {
+  	        return iterable;
+  	      }
+
+  	      if (!isNaN(iterable.length)) {
+  	        var i = -1, next = function next() {
+  	          while (++i < iterable.length) {
+  	            if (hasOwn.call(iterable, i)) {
+  	              next.value = iterable[i];
+  	              next.done = false;
+  	              return next;
+  	            }
+  	          }
+
+  	          next.value = undefined$1;
+  	          next.done = true;
+
+  	          return next;
+  	        };
+
+  	        return next.next = next;
+  	      }
+  	    }
+
+  	    // Return an iterator with no values.
+  	    return { next: doneResult };
+  	  }
+  	  runtime.values = values;
+
+  	  function doneResult() {
+  	    return { value: undefined$1, done: true };
+  	  }
+
+  	  Context.prototype = {
+  	    constructor: Context,
+
+  	    reset: function(skipTempReset) {
+  	      this.prev = 0;
+  	      this.next = 0;
+  	      // Resetting context._sent for legacy support of Babel's
+  	      // function.sent implementation.
+  	      this.sent = this._sent = undefined$1;
+  	      this.done = false;
+  	      this.delegate = null;
+
+  	      this.method = "next";
+  	      this.arg = undefined$1;
+
+  	      this.tryEntries.forEach(resetTryEntry);
+
+  	      if (!skipTempReset) {
+  	        for (var name in this) {
+  	          // Not sure about the optimal order of these conditions:
+  	          if (name.charAt(0) === "t" &&
+  	              hasOwn.call(this, name) &&
+  	              !isNaN(+name.slice(1))) {
+  	            this[name] = undefined$1;
+  	          }
+  	        }
+  	      }
+  	    },
+
+  	    stop: function() {
+  	      this.done = true;
+
+  	      var rootEntry = this.tryEntries[0];
+  	      var rootRecord = rootEntry.completion;
+  	      if (rootRecord.type === "throw") {
+  	        throw rootRecord.arg;
+  	      }
+
+  	      return this.rval;
+  	    },
+
+  	    dispatchException: function(exception) {
+  	      if (this.done) {
+  	        throw exception;
+  	      }
+
+  	      var context = this;
+  	      function handle(loc, caught) {
+  	        record.type = "throw";
+  	        record.arg = exception;
+  	        context.next = loc;
+
+  	        if (caught) {
+  	          // If the dispatched exception was caught by a catch block,
+  	          // then let that catch block handle the exception normally.
+  	          context.method = "next";
+  	          context.arg = undefined$1;
+  	        }
+
+  	        return !! caught;
+  	      }
+
+  	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+  	        var entry = this.tryEntries[i];
+  	        var record = entry.completion;
+
+  	        if (entry.tryLoc === "root") {
+  	          // Exception thrown outside of any try block that could handle
+  	          // it, so set the completion value of the entire function to
+  	          // throw the exception.
+  	          return handle("end");
+  	        }
+
+  	        if (entry.tryLoc <= this.prev) {
+  	          var hasCatch = hasOwn.call(entry, "catchLoc");
+  	          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+  	          if (hasCatch && hasFinally) {
+  	            if (this.prev < entry.catchLoc) {
+  	              return handle(entry.catchLoc, true);
+  	            } else if (this.prev < entry.finallyLoc) {
+  	              return handle(entry.finallyLoc);
+  	            }
+
+  	          } else if (hasCatch) {
+  	            if (this.prev < entry.catchLoc) {
+  	              return handle(entry.catchLoc, true);
+  	            }
+
+  	          } else if (hasFinally) {
+  	            if (this.prev < entry.finallyLoc) {
+  	              return handle(entry.finallyLoc);
+  	            }
+
+  	          } else {
+  	            throw new Error("try statement without catch or finally");
+  	          }
+  	        }
+  	      }
+  	    },
+
+  	    abrupt: function(type, arg) {
+  	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+  	        var entry = this.tryEntries[i];
+  	        if (entry.tryLoc <= this.prev &&
+  	            hasOwn.call(entry, "finallyLoc") &&
+  	            this.prev < entry.finallyLoc) {
+  	          var finallyEntry = entry;
+  	          break;
+  	        }
+  	      }
+
+  	      if (finallyEntry &&
+  	          (type === "break" ||
+  	           type === "continue") &&
+  	          finallyEntry.tryLoc <= arg &&
+  	          arg <= finallyEntry.finallyLoc) {
+  	        // Ignore the finally entry if control is not jumping to a
+  	        // location outside the try/catch block.
+  	        finallyEntry = null;
+  	      }
+
+  	      var record = finallyEntry ? finallyEntry.completion : {};
+  	      record.type = type;
+  	      record.arg = arg;
+
+  	      if (finallyEntry) {
+  	        this.method = "next";
+  	        this.next = finallyEntry.finallyLoc;
+  	        return ContinueSentinel;
+  	      }
+
+  	      return this.complete(record);
+  	    },
+
+  	    complete: function(record, afterLoc) {
+  	      if (record.type === "throw") {
+  	        throw record.arg;
+  	      }
+
+  	      if (record.type === "break" ||
+  	          record.type === "continue") {
+  	        this.next = record.arg;
+  	      } else if (record.type === "return") {
+  	        this.rval = this.arg = record.arg;
+  	        this.method = "return";
+  	        this.next = "end";
+  	      } else if (record.type === "normal" && afterLoc) {
+  	        this.next = afterLoc;
+  	      }
+
+  	      return ContinueSentinel;
+  	    },
+
+  	    finish: function(finallyLoc) {
+  	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+  	        var entry = this.tryEntries[i];
+  	        if (entry.finallyLoc === finallyLoc) {
+  	          this.complete(entry.completion, entry.afterLoc);
+  	          resetTryEntry(entry);
+  	          return ContinueSentinel;
+  	        }
+  	      }
+  	    },
+
+  	    "catch": function(tryLoc) {
+  	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+  	        var entry = this.tryEntries[i];
+  	        if (entry.tryLoc === tryLoc) {
+  	          var record = entry.completion;
+  	          if (record.type === "throw") {
+  	            var thrown = record.arg;
+  	            resetTryEntry(entry);
+  	          }
+  	          return thrown;
+  	        }
+  	      }
+
+  	      // The context.catch method must only be called with a location
+  	      // argument that corresponds to a known catch block.
+  	      throw new Error("illegal catch attempt");
+  	    },
+
+  	    delegateYield: function(iterable, resultName, nextLoc) {
+  	      this.delegate = {
+  	        iterator: values(iterable),
+  	        resultName: resultName,
+  	        nextLoc: nextLoc
+  	      };
+
+  	      if (this.method === "next") {
+  	        // Deliberately forget the last sent value so that we don't
+  	        // accidentally pass it on to the delegate.
+  	        this.arg = undefined$1;
+  	      }
+
+  	      return ContinueSentinel;
+  	    }
+  	  };
+  	})(
+  	  // In sloppy mode, unbound `this` refers to the global object, fallback to
+  	  // Function constructor if we're in global strict mode. That is sadly a form
+  	  // of indirect eval which violates Content Security Policy.
+  	  (function() { return this })() || Function("return this")()
+  	);
+  } (runtime));
+
+  /**
+   * Copyright (c) 2014-present, Facebook, Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+  (function (module) {
+  	// This method of obtaining a reference to the global object needs to be
+  	// kept identical to the way it is obtained in runtime.js
+  	var g = (function() { return this })() || Function("return this")();
+
+  	// Use `getOwnPropertyNames` because not all browsers support calling
+  	// `hasOwnProperty` on the global `self` object in a worker. See #183.
+  	var hadRuntime = g.regeneratorRuntime &&
+  	  Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0;
+
+  	// Save the old regeneratorRuntime in case it needs to be restored later.
+  	var oldRuntime = hadRuntime && g.regeneratorRuntime;
+
+  	// Force reevalutation of runtime.js.
+  	g.regeneratorRuntime = undefined;
+
+  	module.exports = runtimeExports;
+
+  	if (hadRuntime) {
+  	  // Restore the original runtime.
+  	  g.regeneratorRuntime = oldRuntime;
+  	} else {
+  	  // Remove the global property added by runtime.js.
+  	  try {
+  	    delete g.regeneratorRuntime;
+  	  } catch(e) {
+  	    g.regeneratorRuntime = undefined;
+  	  }
+  	}
+  } (runtimeModule));
+
+  (function (module) {
+  	module.exports = runtimeModuleExports;
+  } (regenerator));
+
+  var _extends = {};
+
+  var assignExports = {};
+  var assign$1 = {
+    get exports(){ return assignExports; },
+    set exports(v){ assignExports = v; },
+  };
+
+  var _globalExports = {};
+  var _global = {
+    get exports(){ return _globalExports; },
+    set exports(v){ _globalExports = v; },
+  };
+
+  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+  var global$8 = _global.exports = typeof window != 'undefined' && window.Math == Math
+    ? window : typeof self != 'undefined' && self.Math == Math ? self
+    // eslint-disable-next-line no-new-func
+    : Function('return this')();
+  if (typeof __g == 'number') __g = global$8; // eslint-disable-line no-undef
+
+  var _coreExports = {};
+  var _core = {
+    get exports(){ return _coreExports; },
+    set exports(v){ _coreExports = v; },
+  };
+
+  var core$3 = _core.exports = { version: '2.6.12' };
+  if (typeof __e == 'number') __e = core$3; // eslint-disable-line no-undef
+
+  var _aFunction = function (it) {
+    if (typeof it != 'function') throw TypeError(it + ' is not a function!');
+    return it;
+  };
+
+  // optional / simple context binding
+  var aFunction$3 = _aFunction;
+  var _ctx = function (fn, that, length) {
+    aFunction$3(fn);
+    if (that === undefined) return fn;
+    switch (length) {
+      case 1: return function (a) {
+        return fn.call(that, a);
+      };
+      case 2: return function (a, b) {
+        return fn.call(that, a, b);
+      };
+      case 3: return function (a, b, c) {
+        return fn.call(that, a, b, c);
+      };
+    }
+    return function (/* ...args */) {
+      return fn.apply(that, arguments);
+    };
+  };
+
+  var _objectDp = {};
+
+  var _isObject = function (it) {
+    return typeof it === 'object' ? it !== null : typeof it === 'function';
+  };
+
+  var isObject$4 = _isObject;
+  var _anObject = function (it) {
+    if (!isObject$4(it)) throw TypeError(it + ' is not an object!');
+    return it;
+  };
+
+  var _fails;
+  var hasRequired_fails;
+
+  function require_fails () {
+  	if (hasRequired_fails) return _fails;
+  	hasRequired_fails = 1;
+  	_fails = function (exec) {
+  	  try {
+  	    return !!exec();
+  	  } catch (e) {
+  	    return true;
+  	  }
+  	};
+  	return _fails;
+  }
+
+  // Thank's IE8 for his funny defineProperty
+  var _descriptors = !require_fails()(function () {
+    return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
+  });
+
+  var isObject$3 = _isObject;
+  var document$2 = _globalExports.document;
+  // typeof document.createElement is 'object' in old IE
+  var is = isObject$3(document$2) && isObject$3(document$2.createElement);
+  var _domCreate = function (it) {
+    return is ? document$2.createElement(it) : {};
+  };
+
+  var _ie8DomDefine = !_descriptors && !require_fails()(function () {
+    return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7;
+  });
+
+  // 7.1.1 ToPrimitive(input [, PreferredType])
+  var isObject$2 = _isObject;
+  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
+  // and the second argument - flag - preferred type is a string
+  var _toPrimitive = function (it, S) {
+    if (!isObject$2(it)) return it;
+    var fn, val;
+    if (S && typeof (fn = it.toString) == 'function' && !isObject$2(val = fn.call(it))) return val;
+    if (typeof (fn = it.valueOf) == 'function' && !isObject$2(val = fn.call(it))) return val;
+    if (!S && typeof (fn = it.toString) == 'function' && !isObject$2(val = fn.call(it))) return val;
+    throw TypeError("Can't convert object to primitive value");
+  };
+
+  var anObject$6 = _anObject;
+  var IE8_DOM_DEFINE = _ie8DomDefine;
+  var toPrimitive = _toPrimitive;
+  var dP$2 = Object.defineProperty;
+
+  _objectDp.f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) {
+    anObject$6(O);
+    P = toPrimitive(P, true);
+    anObject$6(Attributes);
+    if (IE8_DOM_DEFINE) try {
+      return dP$2(O, P, Attributes);
+    } catch (e) { /* empty */ }
+    if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
+    if ('value' in Attributes) O[P] = Attributes.value;
+    return O;
+  };
+
+  var _propertyDesc = function (bitmap, value) {
+    return {
+      enumerable: !(bitmap & 1),
+      configurable: !(bitmap & 2),
+      writable: !(bitmap & 4),
+      value: value
+    };
+  };
+
+  var dP$1 = _objectDp;
+  var createDesc = _propertyDesc;
+  var _hide = _descriptors ? function (object, key, value) {
+    return dP$1.f(object, key, createDesc(1, value));
+  } : function (object, key, value) {
+    object[key] = value;
+    return object;
+  };
+
+  var hasOwnProperty = {}.hasOwnProperty;
+  var _has = function (it, key) {
+    return hasOwnProperty.call(it, key);
+  };
+
+  var global$7 = _globalExports;
+  var core$2 = _coreExports;
+  var ctx$3 = _ctx;
+  var hide$2 = _hide;
+  var has$1 = _has;
+  var PROTOTYPE$1 = 'prototype';
+
+  var $export$5 = function (type, name, source) {
+    var IS_FORCED = type & $export$5.F;
+    var IS_GLOBAL = type & $export$5.G;
+    var IS_STATIC = type & $export$5.S;
+    var IS_PROTO = type & $export$5.P;
+    var IS_BIND = type & $export$5.B;
+    var IS_WRAP = type & $export$5.W;
+    var exports = IS_GLOBAL ? core$2 : core$2[name] || (core$2[name] = {});
+    var expProto = exports[PROTOTYPE$1];
+    var target = IS_GLOBAL ? global$7 : IS_STATIC ? global$7[name] : (global$7[name] || {})[PROTOTYPE$1];
+    var key, own, out;
+    if (IS_GLOBAL) source = name;
+    for (key in source) {
+      // contains in native
+      own = !IS_FORCED && target && target[key] !== undefined;
+      if (own && has$1(exports, key)) continue;
+      // export native or passed
+      out = own ? target[key] : source[key];
+      // prevent global pollution for namespaces
+      exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
+      // bind timers to global for call from export context
+      : IS_BIND && own ? ctx$3(out, global$7)
+      // wrap global constructors for prevent change them in library
+      : IS_WRAP && target[key] == out ? (function (C) {
+        var F = function (a, b, c) {
+          if (this instanceof C) {
+            switch (arguments.length) {
+              case 0: return new C();
+              case 1: return new C(a);
+              case 2: return new C(a, b);
+            } return new C(a, b, c);
+          } return C.apply(this, arguments);
+        };
+        F[PROTOTYPE$1] = C[PROTOTYPE$1];
+        return F;
+      // make static versions for prototype methods
+      })(out) : IS_PROTO && typeof out == 'function' ? ctx$3(Function.call, out) : out;
+      // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
+      if (IS_PROTO) {
+        (exports.virtual || (exports.virtual = {}))[key] = out;
+        // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
+        if (type & $export$5.R && expProto && !expProto[key]) hide$2(expProto, key, out);
+      }
+    }
+  };
+  // type bitmap
+  $export$5.F = 1;   // forced
+  $export$5.G = 2;   // global
+  $export$5.S = 4;   // static
+  $export$5.P = 8;   // proto
+  $export$5.B = 16;  // bind
+  $export$5.W = 32;  // wrap
+  $export$5.U = 64;  // safe
+  $export$5.R = 128; // real proto method for `library`
+  var _export = $export$5;
+
+  var toString = {}.toString;
+
+  var _cof = function (it) {
+    return toString.call(it).slice(8, -1);
+  };
+
+  var _iobject;
+  var hasRequired_iobject;
+
+  function require_iobject () {
+  	if (hasRequired_iobject) return _iobject;
+  	hasRequired_iobject = 1;
+  	// fallback for non-array-like ES3 and non-enumerable old V8 strings
+  	var cof = _cof;
+  	// eslint-disable-next-line no-prototype-builtins
+  	_iobject = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
+  	  return cof(it) == 'String' ? it.split('') : Object(it);
+  	};
+  	return _iobject;
+  }
+
+  // 7.2.1 RequireObjectCoercible(argument)
+  var _defined = function (it) {
+    if (it == undefined) throw TypeError("Can't call method on  " + it);
+    return it;
+  };
+
+  // to indexed object, toObject with fallback for non-array-like ES3 strings
+  var IObject = require_iobject();
+  var defined$1 = _defined;
+  var _toIobject = function (it) {
+    return IObject(defined$1(it));
+  };
+
+  // 7.1.4 ToInteger
+  var ceil = Math.ceil;
+  var floor = Math.floor;
+  var _toInteger = function (it) {
+    return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+  };
+
+  // 7.1.15 ToLength
+  var toInteger$1 = _toInteger;
+  var min = Math.min;
+  var _toLength = function (it) {
+    return it > 0 ? min(toInteger$1(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+  };
+
+  var _toAbsoluteIndex;
+  var hasRequired_toAbsoluteIndex;
+
+  function require_toAbsoluteIndex () {
+  	if (hasRequired_toAbsoluteIndex) return _toAbsoluteIndex;
+  	hasRequired_toAbsoluteIndex = 1;
+  	var toInteger = _toInteger;
+  	var max = Math.max;
+  	var min = Math.min;
+  	_toAbsoluteIndex = function (index, length) {
+  	  index = toInteger(index);
+  	  return index < 0 ? max(index + length, 0) : min(index, length);
+  	};
+  	return _toAbsoluteIndex;
+  }
+
+  var _arrayIncludes;
+  var hasRequired_arrayIncludes;
+
+  function require_arrayIncludes () {
+  	if (hasRequired_arrayIncludes) return _arrayIncludes;
+  	hasRequired_arrayIncludes = 1;
+  	// false -> Array#indexOf
+  	// true  -> Array#includes
+  	var toIObject = _toIobject;
+  	var toLength = _toLength;
+  	var toAbsoluteIndex = require_toAbsoluteIndex();
+  	_arrayIncludes = function (IS_INCLUDES) {
+  	  return function ($this, el, fromIndex) {
+  	    var O = toIObject($this);
+  	    var length = toLength(O.length);
+  	    var index = toAbsoluteIndex(fromIndex, length);
+  	    var value;
+  	    // Array#includes uses SameValueZero equality algorithm
+  	    // eslint-disable-next-line no-self-compare
+  	    if (IS_INCLUDES && el != el) while (length > index) {
+  	      value = O[index++];
+  	      // eslint-disable-next-line no-self-compare
+  	      if (value != value) return true;
+  	    // Array#indexOf ignores holes, Array#includes - not
+  	    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
+  	      if (O[index] === el) return IS_INCLUDES || index || 0;
+  	    } return !IS_INCLUDES && -1;
+  	  };
+  	};
+  	return _arrayIncludes;
+  }
+
+  var _sharedExports = {};
+  var _shared = {
+    get exports(){ return _sharedExports; },
+    set exports(v){ _sharedExports = v; },
+  };
+
+  var _library = true;
+
+  var core$1 = _coreExports;
+  var global$6 = _globalExports;
+  var SHARED = '__core-js_shared__';
+  var store$1 = global$6[SHARED] || (global$6[SHARED] = {});
+
+  (_shared.exports = function (key, value) {
+    return store$1[key] || (store$1[key] = value !== undefined ? value : {});
+  })('versions', []).push({
+    version: core$1.version,
+    mode: 'pure' ,
+    copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
+  });
+
+  var id = 0;
+  var px = Math.random();
+  var _uid = function (key) {
+    return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+  };
+
+  var shared = _sharedExports('keys');
+  var uid$1 = _uid;
+  var _sharedKey = function (key) {
+    return shared[key] || (shared[key] = uid$1(key));
+  };
+
+  var _objectKeysInternal;
+  var hasRequired_objectKeysInternal;
+
+  function require_objectKeysInternal () {
+  	if (hasRequired_objectKeysInternal) return _objectKeysInternal;
+  	hasRequired_objectKeysInternal = 1;
+  	var has = _has;
+  	var toIObject = _toIobject;
+  	var arrayIndexOf = require_arrayIncludes()(false);
+  	var IE_PROTO = _sharedKey('IE_PROTO');
+
+  	_objectKeysInternal = function (object, names) {
+  	  var O = toIObject(object);
+  	  var i = 0;
+  	  var result = [];
+  	  var key;
+  	  for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
+  	  // Don't enum bug & hidden keys
+  	  while (names.length > i) if (has(O, key = names[i++])) {
+  	    ~arrayIndexOf(result, key) || result.push(key);
+  	  }
+  	  return result;
+  	};
+  	return _objectKeysInternal;
+  }
+
+  var _enumBugKeys;
+  var hasRequired_enumBugKeys;
+
+  function require_enumBugKeys () {
+  	if (hasRequired_enumBugKeys) return _enumBugKeys;
+  	hasRequired_enumBugKeys = 1;
+  	// IE 8- don't enum bug keys
+  	_enumBugKeys = (
+  	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+  	).split(',');
+  	return _enumBugKeys;
+  }
+
+  var _objectKeys;
+  var hasRequired_objectKeys;
+
+  function require_objectKeys () {
+  	if (hasRequired_objectKeys) return _objectKeys;
+  	hasRequired_objectKeys = 1;
+  	// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+  	var $keys = require_objectKeysInternal();
+  	var enumBugKeys = require_enumBugKeys();
+
+  	_objectKeys = Object.keys || function keys(O) {
+  	  return $keys(O, enumBugKeys);
+  	};
+  	return _objectKeys;
+  }
+
+  var _objectGops = {};
+
+  var hasRequired_objectGops;
+
+  function require_objectGops () {
+  	if (hasRequired_objectGops) return _objectGops;
+  	hasRequired_objectGops = 1;
+  	_objectGops.f = Object.getOwnPropertySymbols;
+  	return _objectGops;
+  }
+
+  var _objectPie = {};
+
+  var hasRequired_objectPie;
+
+  function require_objectPie () {
+  	if (hasRequired_objectPie) return _objectPie;
+  	hasRequired_objectPie = 1;
+  	_objectPie.f = {}.propertyIsEnumerable;
+  	return _objectPie;
+  }
+
+  var _toObject;
+  var hasRequired_toObject;
+
+  function require_toObject () {
+  	if (hasRequired_toObject) return _toObject;
+  	hasRequired_toObject = 1;
+  	// 7.1.13 ToObject(argument)
+  	var defined = _defined;
+  	_toObject = function (it) {
+  	  return Object(defined(it));
+  	};
+  	return _toObject;
+  }
+
+  var _objectAssign;
+  var hasRequired_objectAssign;
+
+  function require_objectAssign () {
+  	if (hasRequired_objectAssign) return _objectAssign;
+  	hasRequired_objectAssign = 1;
+  	// 19.1.2.1 Object.assign(target, source, ...)
+  	var DESCRIPTORS = _descriptors;
+  	var getKeys = require_objectKeys();
+  	var gOPS = require_objectGops();
+  	var pIE = require_objectPie();
+  	var toObject = require_toObject();
+  	var IObject = require_iobject();
+  	var $assign = Object.assign;
+
+  	// should work with symbols and should have deterministic property order (V8 bug)
+  	_objectAssign = !$assign || require_fails()(function () {
+  	  var A = {};
+  	  var B = {};
+  	  // eslint-disable-next-line no-undef
+  	  var S = Symbol();
+  	  var K = 'abcdefghijklmnopqrst';
+  	  A[S] = 7;
+  	  K.split('').forEach(function (k) { B[k] = k; });
+  	  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
+  	}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
+  	  var T = toObject(target);
+  	  var aLen = arguments.length;
+  	  var index = 1;
+  	  var getSymbols = gOPS.f;
+  	  var isEnum = pIE.f;
+  	  while (aLen > index) {
+  	    var S = IObject(arguments[index++]);
+  	    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
+  	    var length = keys.length;
+  	    var j = 0;
+  	    var key;
+  	    while (length > j) {
+  	      key = keys[j++];
+  	      if (!DESCRIPTORS || isEnum.call(S, key)) T[key] = S[key];
+  	    }
+  	  } return T;
+  	} : $assign;
+  	return _objectAssign;
+  }
+
+  // 19.1.3.1 Object.assign(target, source)
+  var $export$4 = _export;
+
+  $export$4($export$4.S + $export$4.F, 'Object', { assign: require_objectAssign() });
+
+  var assign = _coreExports.Object.assign;
+
+  (function (module) {
+  	module.exports = { "default": assign, __esModule: true };
+  } (assign$1));
+
+  _extends.__esModule = true;
+
+  var _assign = assignExports;
+
+  var _assign2 = _interopRequireDefault$1(_assign);
+
+  function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  _extends.default = _assign2.default || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  var asyncToGenerator = {};
+
+  var promiseExports = {};
+  var promise$1 = {
+    get exports(){ return promiseExports; },
+    set exports(v){ promiseExports = v; },
+  };
+
+  var toInteger = _toInteger;
+  var defined = _defined;
+  // true  -> String#at
+  // false -> String#codePointAt
+  var _stringAt = function (TO_STRING) {
+    return function (that, pos) {
+      var s = String(defined(that));
+      var i = toInteger(pos);
+      var l = s.length;
+      var a, b;
+      if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
+      a = s.charCodeAt(i);
+      return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
+        ? TO_STRING ? s.charAt(i) : a
+        : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
+    };
+  };
+
+  var _redefineExports = {};
+  var _redefine = {
+    get exports(){ return _redefineExports; },
+    set exports(v){ _redefineExports = v; },
+  };
+
+  (function (module) {
+  	module.exports = _hide;
+  } (_redefine));
+
+  var _iterators = {};
+
+  var dP = _objectDp;
+  var anObject$5 = _anObject;
+  var getKeys = require_objectKeys();
+
+  var _objectDps = _descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
+    anObject$5(O);
+    var keys = getKeys(Properties);
+    var length = keys.length;
+    var i = 0;
+    var P;
+    while (length > i) dP.f(O, P = keys[i++], Properties[P]);
+    return O;
+  };
+
+  var document$1 = _globalExports.document;
+  var _html = document$1 && document$1.documentElement;
+
+  // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+  var anObject$4 = _anObject;
+  var dPs = _objectDps;
+  var enumBugKeys = require_enumBugKeys();
+  var IE_PROTO$1 = _sharedKey('IE_PROTO');
+  var Empty = function () { /* empty */ };
+  var PROTOTYPE = 'prototype';
+
+  // Create object with fake `null` prototype: use iframe Object with cleared prototype
+  var createDict = function () {
+    // Thrash, waste and sodomy: IE GC bug
+    var iframe = _domCreate('iframe');
+    var i = enumBugKeys.length;
+    var lt = '<';
+    var gt = '>';
+    var iframeDocument;
+    iframe.style.display = 'none';
+    _html.appendChild(iframe);
+    iframe.src = 'javascript:'; // eslint-disable-line no-script-url
+    // createDict = iframe.contentWindow.Object;
+    // html.removeChild(iframe);
+    iframeDocument = iframe.contentWindow.document;
+    iframeDocument.open();
+    iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
+    iframeDocument.close();
+    createDict = iframeDocument.F;
+    while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
+    return createDict();
+  };
+
+  var _objectCreate = Object.create || function create(O, Properties) {
+    var result;
+    if (O !== null) {
+      Empty[PROTOTYPE] = anObject$4(O);
+      result = new Empty();
+      Empty[PROTOTYPE] = null;
+      // add "__proto__" for Object.getPrototypeOf polyfill
+      result[IE_PROTO$1] = O;
+    } else result = createDict();
+    return Properties === undefined ? result : dPs(result, Properties);
+  };
+
+  var _wksExports = {};
+  var _wks = {
+    get exports(){ return _wksExports; },
+    set exports(v){ _wksExports = v; },
+  };
+
+  var store = _sharedExports('wks');
+  var uid = _uid;
+  var Symbol$1 = _globalExports.Symbol;
+  var USE_SYMBOL = typeof Symbol$1 == 'function';
+
+  var $exports = _wks.exports = function (name) {
+    return store[name] || (store[name] =
+      USE_SYMBOL && Symbol$1[name] || (USE_SYMBOL ? Symbol$1 : uid)('Symbol.' + name));
+  };
+
+  $exports.store = store;
+
+  var _setToStringTag;
+  var hasRequired_setToStringTag;
+
+  function require_setToStringTag () {
+  	if (hasRequired_setToStringTag) return _setToStringTag;
+  	hasRequired_setToStringTag = 1;
+  	var def = _objectDp.f;
+  	var has = _has;
+  	var TAG = _wksExports('toStringTag');
+
+  	_setToStringTag = function (it, tag, stat) {
+  	  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
+  	};
+  	return _setToStringTag;
+  }
+
+  var create = _objectCreate;
+  var descriptor = _propertyDesc;
+  var setToStringTag$1 = require_setToStringTag();
+  var IteratorPrototype = {};
+
+  // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+  _hide(IteratorPrototype, _wksExports('iterator'), function () { return this; });
+
+  var _iterCreate = function (Constructor, NAME, next) {
+    Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
+    setToStringTag$1(Constructor, NAME + ' Iterator');
+  };
+
+  // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
+  var has = _has;
+  var toObject = require_toObject();
+  var IE_PROTO = _sharedKey('IE_PROTO');
+  var ObjectProto = Object.prototype;
+
+  var _objectGpo = Object.getPrototypeOf || function (O) {
+    O = toObject(O);
+    if (has(O, IE_PROTO)) return O[IE_PROTO];
+    if (typeof O.constructor == 'function' && O instanceof O.constructor) {
+      return O.constructor.prototype;
+    } return O instanceof Object ? ObjectProto : null;
+  };
+
+  var $export$3 = _export;
+  var redefine = _redefineExports;
+  var hide$1 = _hide;
+  var Iterators$4 = _iterators;
+  var $iterCreate = _iterCreate;
+  var setToStringTag = require_setToStringTag();
+  var getPrototypeOf = _objectGpo;
+  var ITERATOR$2 = _wksExports('iterator');
+  var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
+  var FF_ITERATOR = '@@iterator';
+  var KEYS = 'keys';
+  var VALUES = 'values';
+
+  var returnThis = function () { return this; };
+
+  var _iterDefine = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
+    $iterCreate(Constructor, NAME, next);
+    var getMethod = function (kind) {
+      if (!BUGGY && kind in proto) return proto[kind];
+      switch (kind) {
+        case KEYS: return function keys() { return new Constructor(this, kind); };
+        case VALUES: return function values() { return new Constructor(this, kind); };
+      } return function entries() { return new Constructor(this, kind); };
+    };
+    var TAG = NAME + ' Iterator';
+    var DEF_VALUES = DEFAULT == VALUES;
+    var VALUES_BUG = false;
+    var proto = Base.prototype;
+    var $native = proto[ITERATOR$2] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
+    var $default = $native || getMethod(DEFAULT);
+    var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
+    var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
+    var methods, key, IteratorPrototype;
+    // Fix native
+    if ($anyNative) {
+      IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
+      if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
+        // Set @@toStringTag to native iterators
+        setToStringTag(IteratorPrototype, TAG, true);
+      }
+    }
+    // fix Array#{values, @@iterator}.name in V8 / FF
+    if (DEF_VALUES && $native && $native.name !== VALUES) {
+      VALUES_BUG = true;
+      $default = function values() { return $native.call(this); };
+    }
+    // Define iterator
+    if ((FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR$2])) {
+      hide$1(proto, ITERATOR$2, $default);
+    }
+    // Plug for library
+    Iterators$4[NAME] = $default;
+    Iterators$4[TAG] = returnThis;
+    if (DEFAULT) {
+      methods = {
+        values: DEF_VALUES ? $default : getMethod(VALUES),
+        keys: IS_SET ? $default : getMethod(KEYS),
+        entries: $entries
+      };
+      if (FORCED) for (key in methods) {
+        if (!(key in proto)) redefine(proto, key, methods[key]);
+      } else $export$3($export$3.P + $export$3.F * (BUGGY || VALUES_BUG), NAME, methods);
+    }
+    return methods;
+  };
+
+  var $at = _stringAt(true);
+
+  // 21.1.3.27 String.prototype[@@iterator]()
+  _iterDefine(String, 'String', function (iterated) {
+    this._t = String(iterated); // target
+    this._i = 0;                // next index
+  // 21.1.5.2.1 %StringIteratorPrototype%.next()
+  }, function () {
+    var O = this._t;
+    var index = this._i;
+    var point;
+    if (index >= O.length) return { value: undefined, done: true };
+    point = $at(O, index);
+    this._i += point.length;
+    return { value: point, done: false };
+  });
+
+  var _iterStep = function (done, value) {
+    return { value: value, done: !!done };
+  };
+
+  var step = _iterStep;
+  var Iterators$3 = _iterators;
+  var toIObject = _toIobject;
+
+  // 22.1.3.4 Array.prototype.entries()
+  // 22.1.3.13 Array.prototype.keys()
+  // 22.1.3.29 Array.prototype.values()
+  // 22.1.3.30 Array.prototype[@@iterator]()
+  _iterDefine(Array, 'Array', function (iterated, kind) {
+    this._t = toIObject(iterated); // target
+    this._i = 0;                   // next index
+    this._k = kind;                // kind
+  // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
+  }, function () {
+    var O = this._t;
+    var kind = this._k;
+    var index = this._i++;
+    if (!O || index >= O.length) {
+      this._t = undefined;
+      return step(1);
+    }
+    if (kind == 'keys') return step(0, index);
+    if (kind == 'values') return step(0, O[index]);
+    return step(0, [index, O[index]]);
+  }, 'values');
+
+  // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
+  Iterators$3.Arguments = Iterators$3.Array;
+
+  var global$5 = _globalExports;
+  var hide = _hide;
+  var Iterators$2 = _iterators;
+  var TO_STRING_TAG = _wksExports('toStringTag');
+
+  var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
+    'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
+    'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
+    'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
+    'TextTrackList,TouchList').split(',');
+
+  for (var i = 0; i < DOMIterables.length; i++) {
+    var NAME = DOMIterables[i];
+    var Collection = global$5[NAME];
+    var proto = Collection && Collection.prototype;
+    if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
+    Iterators$2[NAME] = Iterators$2.Array;
+  }
+
+  // getting tag from 19.1.3.6 Object.prototype.toString()
+  var cof = _cof;
+  var TAG = _wksExports('toStringTag');
+  // ES3 wrong here
+  var ARG = cof(function () { return arguments; }()) == 'Arguments';
+
+  // fallback for IE11 Script Access Denied error
+  var tryGet = function (it, key) {
+    try {
+      return it[key];
+    } catch (e) { /* empty */ }
+  };
+
+  var _classof = function (it) {
+    var O, T, B;
+    return it === undefined ? 'Undefined' : it === null ? 'Null'
+      // @@toStringTag case
+      : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
+      // builtinTag case
+      : ARG ? cof(O)
+      // ES3 arguments fallback
+      : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
+  };
+
+  var _anInstance = function (it, Constructor, name, forbiddenField) {
+    if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
+      throw TypeError(name + ': incorrect invocation!');
+    } return it;
+  };
+
+  var _forOfExports = {};
+  var _forOf = {
+    get exports(){ return _forOfExports; },
+    set exports(v){ _forOfExports = v; },
+  };
+
+  // call something on iterator step with safe closing on error
+  var anObject$3 = _anObject;
+  var _iterCall = function (iterator, fn, value, entries) {
+    try {
+      return entries ? fn(anObject$3(value)[0], value[1]) : fn(value);
+    // 7.4.6 IteratorClose(iterator, completion)
+    } catch (e) {
+      var ret = iterator['return'];
+      if (ret !== undefined) anObject$3(ret.call(iterator));
+      throw e;
+    }
+  };
+
+  // check on default Array iterator
+  var Iterators$1 = _iterators;
+  var ITERATOR$1 = _wksExports('iterator');
+  var ArrayProto = Array.prototype;
+
+  var _isArrayIter = function (it) {
+    return it !== undefined && (Iterators$1.Array === it || ArrayProto[ITERATOR$1] === it);
+  };
+
+  var classof$1 = _classof;
+  var ITERATOR = _wksExports('iterator');
+  var Iterators = _iterators;
+  var core_getIteratorMethod = _coreExports.getIteratorMethod = function (it) {
+    if (it != undefined) return it[ITERATOR]
+      || it['@@iterator']
+      || Iterators[classof$1(it)];
+  };
+
+  var ctx$2 = _ctx;
+  var call = _iterCall;
+  var isArrayIter = _isArrayIter;
+  var anObject$2 = _anObject;
+  var toLength = _toLength;
+  var getIterFn = core_getIteratorMethod;
+  var BREAK = {};
+  var RETURN = {};
+  var exports$1 = _forOf.exports = function (iterable, entries, fn, that, ITERATOR) {
+    var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
+    var f = ctx$2(fn, that, entries ? 2 : 1);
+    var index = 0;
+    var length, step, iterator, result;
+    if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
+    // fast case for arrays with default iterator
+    if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
+      result = entries ? f(anObject$2(step = iterable[index])[0], step[1]) : f(iterable[index]);
+      if (result === BREAK || result === RETURN) return result;
+    } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
+      result = call(iterator, f, step.value, entries);
+      if (result === BREAK || result === RETURN) return result;
+    }
+  };
+  exports$1.BREAK = BREAK;
+  exports$1.RETURN = RETURN;
+
+  // 7.3.20 SpeciesConstructor(O, defaultConstructor)
+  var anObject$1 = _anObject;
+  var aFunction$2 = _aFunction;
+  var SPECIES = _wksExports('species');
+  var _speciesConstructor = function (O, D) {
+    var C = anObject$1(O).constructor;
+    var S;
+    return C === undefined || (S = anObject$1(C)[SPECIES]) == undefined ? D : aFunction$2(S);
+  };
+
+  // fast apply, http://jsperf.lnkit.com/fast-apply/5
+  var _invoke = function (fn, args, that) {
+    var un = that === undefined;
+    switch (args.length) {
+      case 0: return un ? fn()
+                        : fn.call(that);
+      case 1: return un ? fn(args[0])
+                        : fn.call(that, args[0]);
+      case 2: return un ? fn(args[0], args[1])
+                        : fn.call(that, args[0], args[1]);
+      case 3: return un ? fn(args[0], args[1], args[2])
+                        : fn.call(that, args[0], args[1], args[2]);
+      case 4: return un ? fn(args[0], args[1], args[2], args[3])
+                        : fn.call(that, args[0], args[1], args[2], args[3]);
+    } return fn.apply(that, args);
+  };
+
+  var ctx$1 = _ctx;
+  var invoke = _invoke;
+  var html = _html;
+  var cel = _domCreate;
+  var global$4 = _globalExports;
+  var process$2 = global$4.process;
+  var setTask = global$4.setImmediate;
+  var clearTask = global$4.clearImmediate;
+  var MessageChannel = global$4.MessageChannel;
+  var Dispatch = global$4.Dispatch;
+  var counter = 0;
+  var queue = {};
+  var ONREADYSTATECHANGE = 'onreadystatechange';
+  var defer, channel, port;
+  var run = function () {
+    var id = +this;
+    // eslint-disable-next-line no-prototype-builtins
+    if (queue.hasOwnProperty(id)) {
+      var fn = queue[id];
+      delete queue[id];
+      fn();
+    }
+  };
+  var listener = function (event) {
+    run.call(event.data);
+  };
+  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+  if (!setTask || !clearTask) {
+    setTask = function setImmediate(fn) {
+      var args = [];
+      var i = 1;
+      while (arguments.length > i) args.push(arguments[i++]);
+      queue[++counter] = function () {
+        // eslint-disable-next-line no-new-func
+        invoke(typeof fn == 'function' ? fn : Function(fn), args);
+      };
+      defer(counter);
+      return counter;
+    };
+    clearTask = function clearImmediate(id) {
+      delete queue[id];
+    };
+    // Node.js 0.8-
+    if (_cof(process$2) == 'process') {
+      defer = function (id) {
+        process$2.nextTick(ctx$1(run, id, 1));
+      };
+    // Sphere (JS game engine) Dispatch API
+    } else if (Dispatch && Dispatch.now) {
+      defer = function (id) {
+        Dispatch.now(ctx$1(run, id, 1));
+      };
+    // Browsers with MessageChannel, includes WebWorkers
+    } else if (MessageChannel) {
+      channel = new MessageChannel();
+      port = channel.port2;
+      channel.port1.onmessage = listener;
+      defer = ctx$1(port.postMessage, port, 1);
+    // Browsers with postMessage, skip WebWorkers
+    // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+    } else if (global$4.addEventListener && typeof postMessage == 'function' && !global$4.importScripts) {
+      defer = function (id) {
+        global$4.postMessage(id + '', '*');
+      };
+      global$4.addEventListener('message', listener, false);
+    // IE8-
+    } else if (ONREADYSTATECHANGE in cel('script')) {
+      defer = function (id) {
+        html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
+          html.removeChild(this);
+          run.call(id);
+        };
+      };
+    // Rest old browsers
+    } else {
+      defer = function (id) {
+        setTimeout(ctx$1(run, id, 1), 0);
+      };
+    }
+  }
+  var _task = {
+    set: setTask,
+    clear: clearTask
+  };
+
+  var global$3 = _globalExports;
+  var macrotask = _task.set;
+  var Observer = global$3.MutationObserver || global$3.WebKitMutationObserver;
+  var process$1 = global$3.process;
+  var Promise$1 = global$3.Promise;
+  var isNode$1 = _cof(process$1) == 'process';
+
+  var _microtask = function () {
+    var head, last, notify;
+
+    var flush = function () {
+      var parent, fn;
+      if (isNode$1 && (parent = process$1.domain)) parent.exit();
+      while (head) {
+        fn = head.fn;
+        head = head.next;
+        try {
+          fn();
+        } catch (e) {
+          if (head) notify();
+          else last = undefined;
+          throw e;
+        }
+      } last = undefined;
+      if (parent) parent.enter();
+    };
+
+    // Node.js
+    if (isNode$1) {
+      notify = function () {
+        process$1.nextTick(flush);
+      };
+    // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339
+    } else if (Observer && !(global$3.navigator && global$3.navigator.standalone)) {
+      var toggle = true;
+      var node = document.createTextNode('');
+      new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
+      notify = function () {
+        node.data = toggle = !toggle;
+      };
+    // environments with maybe non-completely correct, but existent Promise
+    } else if (Promise$1 && Promise$1.resolve) {
+      // Promise.resolve without an argument throws an error in LG WebOS 2
+      var promise = Promise$1.resolve(undefined);
+      notify = function () {
+        promise.then(flush);
+      };
+    // for other environments - macrotask based on:
+    // - setImmediate
+    // - MessageChannel
+    // - window.postMessag
+    // - onreadystatechange
+    // - setTimeout
+    } else {
+      notify = function () {
+        // strange IE + webpack dev server bug - use .call(global)
+        macrotask.call(global$3, flush);
+      };
+    }
+
+    return function (fn) {
+      var task = { fn: fn, next: undefined };
+      if (last) last.next = task;
+      if (!head) {
+        head = task;
+        notify();
+      } last = task;
+    };
+  };
+
+  var _newPromiseCapability = {};
+
+  // 25.4.1.5 NewPromiseCapability(C)
+  var aFunction$1 = _aFunction;
+
+  function PromiseCapability(C) {
+    var resolve, reject;
+    this.promise = new C(function ($$resolve, $$reject) {
+      if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
+      resolve = $$resolve;
+      reject = $$reject;
+    });
+    this.resolve = aFunction$1(resolve);
+    this.reject = aFunction$1(reject);
+  }
+
+  _newPromiseCapability.f = function (C) {
+    return new PromiseCapability(C);
+  };
+
+  var _perform = function (exec) {
+    try {
+      return { e: false, v: exec() };
+    } catch (e) {
+      return { e: true, v: e };
+    }
+  };
+
+  var global$2 = _globalExports;
+  var navigator$1 = global$2.navigator;
+
+  var _userAgent = navigator$1 && navigator$1.userAgent || '';
+
+  var anObject = _anObject;
+  var isObject$1 = _isObject;
+  var newPromiseCapability$2 = _newPromiseCapability;
+
+  var _promiseResolve = function (C, x) {
+    anObject(C);
+    if (isObject$1(x) && x.constructor === C) return x;
+    var promiseCapability = newPromiseCapability$2.f(C);
+    var resolve = promiseCapability.resolve;
+    resolve(x);
+    return promiseCapability.promise;
+  };
+
+  var _redefineAll;
+  var hasRequired_redefineAll;
+
+  function require_redefineAll () {
+  	if (hasRequired_redefineAll) return _redefineAll;
+  	hasRequired_redefineAll = 1;
+  	var hide = _hide;
+  	_redefineAll = function (target, src, safe) {
+  	  for (var key in src) {
+  	    if (safe && target[key]) target[key] = src[key];
+  	    else hide(target, key, src[key]);
+  	  } return target;
+  	};
+  	return _redefineAll;
+  }
+
+  var _setSpecies;
+  var hasRequired_setSpecies;
+
+  function require_setSpecies () {
+  	if (hasRequired_setSpecies) return _setSpecies;
+  	hasRequired_setSpecies = 1;
+  	var global = _globalExports;
+  	var core = _coreExports;
+  	var dP = _objectDp;
+  	var DESCRIPTORS = _descriptors;
+  	var SPECIES = _wksExports('species');
+
+  	_setSpecies = function (KEY) {
+  	  var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];
+  	  if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
+  	    configurable: true,
+  	    get: function () { return this; }
+  	  });
+  	};
+  	return _setSpecies;
+  }
+
+  var _iterDetect;
+  var hasRequired_iterDetect;
+
+  function require_iterDetect () {
+  	if (hasRequired_iterDetect) return _iterDetect;
+  	hasRequired_iterDetect = 1;
+  	var ITERATOR = _wksExports('iterator');
+  	var SAFE_CLOSING = false;
+
+  	try {
+  	  var riter = [7][ITERATOR]();
+  	  riter['return'] = function () { SAFE_CLOSING = true; };
+  	  // eslint-disable-next-line no-throw-literal
+  	  Array.from(riter, function () { throw 2; });
+  	} catch (e) { /* empty */ }
+
+  	_iterDetect = function (exec, skipClosing) {
+  	  if (!skipClosing && !SAFE_CLOSING) return false;
+  	  var safe = false;
+  	  try {
+  	    var arr = [7];
+  	    var iter = arr[ITERATOR]();
+  	    iter.next = function () { return { done: safe = true }; };
+  	    arr[ITERATOR] = function () { return iter; };
+  	    exec(arr);
+  	  } catch (e) { /* empty */ }
+  	  return safe;
+  	};
+  	return _iterDetect;
+  }
+
+  var LIBRARY = _library;
+  var global$1 = _globalExports;
+  var ctx = _ctx;
+  var classof = _classof;
+  var $export$2 = _export;
+  var isObject = _isObject;
+  var aFunction = _aFunction;
+  var anInstance = _anInstance;
+  var forOf = _forOfExports;
+  var speciesConstructor$1 = _speciesConstructor;
+  var task = _task.set;
+  var microtask = _microtask();
+  var newPromiseCapabilityModule = _newPromiseCapability;
+  var perform$1 = _perform;
+  var userAgent = _userAgent;
+  var promiseResolve$1 = _promiseResolve;
+  var PROMISE = 'Promise';
+  var TypeError$1 = global$1.TypeError;
+  var process = global$1.process;
+  var versions = process && process.versions;
+  var v8 = versions && versions.v8 || '';
+  var $Promise = global$1[PROMISE];
+  var isNode = classof(process) == 'process';
+  var empty = function () { /* empty */ };
+  var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
+  var newPromiseCapability$1 = newGenericPromiseCapability = newPromiseCapabilityModule.f;
+
+  var USE_NATIVE = !!function () {
+    try {
+      // correct subclassing with @@species support
+      var promise = $Promise.resolve(1);
+      var FakePromise = (promise.constructor = {})[_wksExports('species')] = function (exec) {
+        exec(empty, empty);
+      };
+      // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+      return (isNode || typeof PromiseRejectionEvent == 'function')
+        && promise.then(empty) instanceof FakePromise
+        // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
+        // we can't detect it synchronously, so just check versions
+        && v8.indexOf('6.6') !== 0
+        && userAgent.indexOf('Chrome/66') === -1;
+    } catch (e) { /* empty */ }
+  }();
+
+  // helpers
+  var isThenable = function (it) {
+    var then;
+    return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
+  };
+  var notify = function (promise, isReject) {
+    if (promise._n) return;
+    promise._n = true;
+    var chain = promise._c;
+    microtask(function () {
+      var value = promise._v;
+      var ok = promise._s == 1;
+      var i = 0;
+      var run = function (reaction) {
+        var handler = ok ? reaction.ok : reaction.fail;
+        var resolve = reaction.resolve;
+        var reject = reaction.reject;
+        var domain = reaction.domain;
+        var result, then, exited;
+        try {
+          if (handler) {
+            if (!ok) {
+              if (promise._h == 2) onHandleUnhandled(promise);
+              promise._h = 1;
+            }
+            if (handler === true) result = value;
+            else {
+              if (domain) domain.enter();
+              result = handler(value); // may throw
+              if (domain) {
+                domain.exit();
+                exited = true;
+              }
+            }
+            if (result === reaction.promise) {
+              reject(TypeError$1('Promise-chain cycle'));
+            } else if (then = isThenable(result)) {
+              then.call(result, resolve, reject);
+            } else resolve(result);
+          } else reject(value);
+        } catch (e) {
+          if (domain && !exited) domain.exit();
+          reject(e);
+        }
+      };
+      while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
+      promise._c = [];
+      promise._n = false;
+      if (isReject && !promise._h) onUnhandled(promise);
+    });
+  };
+  var onUnhandled = function (promise) {
+    task.call(global$1, function () {
+      var value = promise._v;
+      var unhandled = isUnhandled(promise);
+      var result, handler, console;
+      if (unhandled) {
+        result = perform$1(function () {
+          if (isNode) {
+            process.emit('unhandledRejection', value, promise);
+          } else if (handler = global$1.onunhandledrejection) {
+            handler({ promise: promise, reason: value });
+          } else if ((console = global$1.console) && console.error) {
+            console.error('Unhandled promise rejection', value);
+          }
+        });
+        // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+        promise._h = isNode || isUnhandled(promise) ? 2 : 1;
+      } promise._a = undefined;
+      if (unhandled && result.e) throw result.v;
+    });
+  };
+  var isUnhandled = function (promise) {
+    return promise._h !== 1 && (promise._a || promise._c).length === 0;
+  };
+  var onHandleUnhandled = function (promise) {
+    task.call(global$1, function () {
+      var handler;
+      if (isNode) {
+        process.emit('rejectionHandled', promise);
+      } else if (handler = global$1.onrejectionhandled) {
+        handler({ promise: promise, reason: promise._v });
+      }
+    });
+  };
+  var $reject = function (value) {
+    var promise = this;
+    if (promise._d) return;
+    promise._d = true;
+    promise = promise._w || promise; // unwrap
+    promise._v = value;
+    promise._s = 2;
+    if (!promise._a) promise._a = promise._c.slice();
+    notify(promise, true);
+  };
+  var $resolve = function (value) {
+    var promise = this;
+    var then;
+    if (promise._d) return;
+    promise._d = true;
+    promise = promise._w || promise; // unwrap
+    try {
+      if (promise === value) throw TypeError$1("Promise can't be resolved itself");
+      if (then = isThenable(value)) {
+        microtask(function () {
+          var wrapper = { _w: promise, _d: false }; // wrap
+          try {
+            then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
+          } catch (e) {
+            $reject.call(wrapper, e);
+          }
+        });
+      } else {
+        promise._v = value;
+        promise._s = 1;
+        notify(promise, false);
+      }
+    } catch (e) {
+      $reject.call({ _w: promise, _d: false }, e); // wrap
+    }
+  };
+
+  // constructor polyfill
+  if (!USE_NATIVE) {
+    // 25.4.3.1 Promise(executor)
+    $Promise = function Promise(executor) {
+      anInstance(this, $Promise, PROMISE, '_h');
+      aFunction(executor);
+      Internal.call(this);
+      try {
+        executor(ctx($resolve, this, 1), ctx($reject, this, 1));
+      } catch (err) {
+        $reject.call(this, err);
+      }
+    };
+    // eslint-disable-next-line no-unused-vars
+    Internal = function Promise(executor) {
+      this._c = [];             // <- awaiting reactions
+      this._a = undefined;      // <- checked in isUnhandled reactions
+      this._s = 0;              // <- state
+      this._d = false;          // <- done
+      this._v = undefined;      // <- value
+      this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
+      this._n = false;          // <- notify
+    };
+    Internal.prototype = require_redefineAll()($Promise.prototype, {
+      // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
+      then: function then(onFulfilled, onRejected) {
+        var reaction = newPromiseCapability$1(speciesConstructor$1(this, $Promise));
+        reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
+        reaction.fail = typeof onRejected == 'function' && onRejected;
+        reaction.domain = isNode ? process.domain : undefined;
+        this._c.push(reaction);
+        if (this._a) this._a.push(reaction);
+        if (this._s) notify(this, false);
+        return reaction.promise;
+      },
+      // 25.4.5.1 Promise.prototype.catch(onRejected)
+      'catch': function (onRejected) {
+        return this.then(undefined, onRejected);
+      }
+    });
+    OwnPromiseCapability = function () {
+      var promise = new Internal();
+      this.promise = promise;
+      this.resolve = ctx($resolve, promise, 1);
+      this.reject = ctx($reject, promise, 1);
+    };
+    newPromiseCapabilityModule.f = newPromiseCapability$1 = function (C) {
+      return C === $Promise || C === Wrapper
+        ? new OwnPromiseCapability(C)
+        : newGenericPromiseCapability(C);
+    };
+  }
+
+  $export$2($export$2.G + $export$2.W + $export$2.F * !USE_NATIVE, { Promise: $Promise });
+  require_setToStringTag()($Promise, PROMISE);
+  require_setSpecies()(PROMISE);
+  Wrapper = _coreExports[PROMISE];
+
+  // statics
+  $export$2($export$2.S + $export$2.F * !USE_NATIVE, PROMISE, {
+    // 25.4.4.5 Promise.reject(r)
+    reject: function reject(r) {
+      var capability = newPromiseCapability$1(this);
+      var $$reject = capability.reject;
+      $$reject(r);
+      return capability.promise;
+    }
+  });
+  $export$2($export$2.S + $export$2.F * (LIBRARY ), PROMISE, {
+    // 25.4.4.6 Promise.resolve(x)
+    resolve: function resolve(x) {
+      return promiseResolve$1(this === Wrapper ? $Promise : this, x);
+    }
+  });
+  $export$2($export$2.S + $export$2.F * !(USE_NATIVE && require_iterDetect()(function (iter) {
+    $Promise.all(iter)['catch'](empty);
+  })), PROMISE, {
+    // 25.4.4.1 Promise.all(iterable)
+    all: function all(iterable) {
+      var C = this;
+      var capability = newPromiseCapability$1(C);
+      var resolve = capability.resolve;
+      var reject = capability.reject;
+      var result = perform$1(function () {
+        var values = [];
+        var index = 0;
+        var remaining = 1;
+        forOf(iterable, false, function (promise) {
+          var $index = index++;
+          var alreadyCalled = false;
+          values.push(undefined);
+          remaining++;
+          C.resolve(promise).then(function (value) {
+            if (alreadyCalled) return;
+            alreadyCalled = true;
+            values[$index] = value;
+            --remaining || resolve(values);
+          }, reject);
+        });
+        --remaining || resolve(values);
+      });
+      if (result.e) reject(result.v);
+      return capability.promise;
+    },
+    // 25.4.4.4 Promise.race(iterable)
+    race: function race(iterable) {
+      var C = this;
+      var capability = newPromiseCapability$1(C);
+      var reject = capability.reject;
+      var result = perform$1(function () {
+        forOf(iterable, false, function (promise) {
+          C.resolve(promise).then(capability.resolve, reject);
+        });
+      });
+      if (result.e) reject(result.v);
+      return capability.promise;
+    }
+  });
+
+  var $export$1 = _export;
+  var core = _coreExports;
+  var global = _globalExports;
+  var speciesConstructor = _speciesConstructor;
+  var promiseResolve = _promiseResolve;
+
+  $export$1($export$1.P + $export$1.R, 'Promise', { 'finally': function (onFinally) {
+    var C = speciesConstructor(this, core.Promise || global.Promise);
+    var isFunction = typeof onFinally == 'function';
+    return this.then(
+      isFunction ? function (x) {
+        return promiseResolve(C, onFinally()).then(function () { return x; });
+      } : onFinally,
+      isFunction ? function (e) {
+        return promiseResolve(C, onFinally()).then(function () { throw e; });
+      } : onFinally
+    );
+  } });
+
+  // https://github.com/tc39/proposal-promise-try
+  var $export = _export;
+  var newPromiseCapability = _newPromiseCapability;
+  var perform = _perform;
+
+  $export($export.S, 'Promise', { 'try': function (callbackfn) {
+    var promiseCapability = newPromiseCapability.f(this);
+    var result = perform(callbackfn);
+    (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
+    return promiseCapability.promise;
+  } });
+
+  var promise = _coreExports.Promise;
+
+  (function (module) {
+  	module.exports = { "default": promise, __esModule: true };
+  } (promise$1));
+
+  asyncToGenerator.__esModule = true;
+
+  var _promise = promiseExports;
+
+  var _promise2 = _interopRequireDefault(_promise);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  asyncToGenerator.default = function (fn) {
+    return function () {
+      var gen = fn.apply(this, arguments);
+      return new _promise2.default(function (resolve, reject) {
+        function step(key, arg) {
+          try {
+            var info = gen[key](arg);
+            var value = info.value;
+          } catch (error) {
+            reject(error);
+            return;
+          }
+
+          if (info.done) {
+            resolve(value);
+          } else {
+            return _promise2.default.resolve(value).then(function (value) {
+              step("next", value);
+            }, function (err) {
+              step("throw", err);
+            });
+          }
+        }
+
+        return step("next");
+      });
+    };
+  };
+
+  var browserExports = {};
+  var browser = {
+    get exports(){ return browserExports; },
+    set exports(v){ browserExports = v; },
+  };
+
+  (function (module, exports) {
+
+  	exports.__esModule = true;
+  	var userAgent = navigator.userAgent.toLowerCase();
+  	var browser = {};
+  	var uaMatch = void 0;
+  	// 判断页面是否被iframe引用
+  	if (top.location == location) {
+  	  if (uaMatch = userAgent.match(/micromessenger\/([\S]+)/)) {
+  	    browser['name'] = 'wechat';
+  	    browser['version'] = uaMatch[1];
+  	  } else if (uaMatch = userAgent.match(/qq\/([\S]+)/i)) {
+  	    browser['name'] = 'qq';
+  	    browser['version'] = uaMatch[1];
+  	  }
+  	}
+
+  	exports['default'] = browser;
+  	module.exports = exports['default'];
+  } (browser, browserExports));
+
+  var requireJsExports = {};
+  var requireJs = {
+    get exports(){ return requireJsExports; },
+    set exports(v){ requireJsExports = v; },
+  };
+
+  (function (module, exports) {
+
+  	exports.__esModule = true;
+
+  	exports['default'] = function (url, onload) {
+  	  var doc = document;
+  	  var head = doc.head || doc.getElementsByTagName('head')[0] || doc.documentElement;
+  	  var node = doc.createElement('script');
+  	  node.onload = onload;
+  	  node.onerror = function () {};
+  	  node.async = true;
+  	  node.src = url;
+  	  head.appendChild(node);
+  	};
+
+  	module.exports = exports['default'];
+  } (requireJs, requireJsExports));
+
+  (function (module, exports) {
+
+  	exports.__esModule = true;
+
+  	var _regenerator = regeneratorExports;
+
+  	var _regenerator2 = _interopRequireDefault(_regenerator);
+
+  	var _extends2 = _extends;
+
+  	var _extends3 = _interopRequireDefault(_extends2);
+
+  	var _asyncToGenerator2 = asyncToGenerator;
+
+  	var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
+
+  	var share = function () {
+  	  var _ref = (0, _asyncToGenerator3["default"])( /*#__PURE__*/_regenerator2["default"].mark(function _callee(option) {
+  	    var defaultOption;
+  	    return _regenerator2["default"].wrap(function _callee$(_context) {
+  	      while (1) {
+  	        switch (_context.prev = _context.next) {
+  	          case 0:
+  	            if (!(_browser2["default"].name !== "qq")) {
+  	              _context.next = 2;
+  	              break;
+  	            }
+
+  	            return _context.abrupt("return");
+
+  	          case 2:
+  	            if (window.mqq) {
+  	              _context.next = 5;
+  	              break;
+  	            }
+
+  	            _context.next = 5;
+  	            return loadQQSDK();
+
+  	          case 5:
+  	            defaultOption = {
+  	              link: location.href,
+  	              title: "",
+  	              desc: "",
+  	              imgUrl: ""
+  	            };
+
+
+  	            setShareInfo((0, _extends3["default"])({}, defaultOption, option));
+
+  	          case 7:
+  	          case "end":
+  	            return _context.stop();
+  	        }
+  	      }
+  	    }, _callee, this);
+  	  }));
+
+  	  return function share(_x) {
+  	    return _ref.apply(this, arguments);
+  	  };
+  	}();
+
+  	var _browser = browserExports;
+
+  	var _browser2 = _interopRequireDefault(_browser);
+
+  	var _requireJs = requireJsExports;
+
+  	var _requireJs2 = _interopRequireDefault(_requireJs);
+
+  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+  	function loadQQSDK() {
+  	  return new Promise(function (resolve) {
+  	    (0, _requireJs2["default"])("//open.mobile.qq.com/sdk/qqapi.js?_bid=152", function () {
+  	      resolve();
+  	    });
+  	  });
+  	}
+  	var setShareInfo = function setShareInfo(opt) {
+  	  window.mqq.invoke("data", "setShareInfo", {
+  	    share_url: opt.link,
+  	    title: opt.title,
+  	    desc: opt.desc,
+  	    image_url: opt.imgUrl
+  	  });
+  	};
+  	exports["default"] = share;
+  	module.exports = exports['default'];
+  } (qqShare, qqShareExports));
+
+  (function (module, exports) {
+
+  	exports.__esModule = true;
+
+  	var _qqShare = qqShareExports;
+
+  	var _qqShare2 = _interopRequireDefault(_qqShare);
+
+  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+  	exports["default"] = _qqShare2["default"];
+  	module.exports = exports['default'];
+  } (lib, libExports));
+
   /**
    * 复制到剪切板
    *
@@ -543,7 +3058,8 @@
     return formatUrlParams(url, keepParamsObj, forceHistoryMode);
   }
 
-  const DEFAULT_SHARE_ICON = 'http://ossweb-img.qq.com/images/pmd/igameapp/logo/log_igame_3.0.png';
+  const MQQ_SOURCE = 'igame_source';
+  const DEFAULT_SHARE_ICON = '';
   const DEFAULT_TIP_MAP = {
       copyTextSuccess: '复制链接成功，快去粘贴吧！',
       copyTextFail: '该浏览器不支持自动复制',
@@ -558,6 +3074,12 @@
       QQ: 3,
       QZone: 4,
   };
+  const FEATURE_IDS = {
+      /** 默认：结构化消息 */
+      DEFAULT: 'webview_default',
+      /** 图片 */
+      IMAGE: 'webview_image',
+  };
 
   let shareObject = {
       title: '',
@@ -572,6 +3094,7 @@
   };
   let isWzydShare = false; // 显示王者营地样式的分享提示浮层
   let wzydShareText = '点击“...”分享链接';
+  let hasInitQQShare = false; // 是否已初始化过QQ分享
   function getEnv() {
       const ua = navigator.userAgent.toLowerCase();
       const env = Object.assign({ ua }, getEnvUAType());
@@ -1183,27 +3706,32 @@
       var _a;
       (_a = shareUiObj.initCommShareTip) === null || _a === void 0 ? void 0 : _a.call(shareUiObj);
       loader('https://pub.idqqimg.com/qqmobile/qqapi.js?_bid=2538', () => {
-          var _a, _b;
-          (_b = (_a = window === null || window === void 0 ? void 0 : window.mqq) === null || _a === void 0 ? void 0 : _a.ui) === null || _b === void 0 ? void 0 : _b.setOnShareHandler(
-          // http://mqq.oa.com/api.html#js-mqq-core
-          (type) => {
-              if (type == 0 || type == 1 || type == 2 || type == 3 || type == 11) {
-                  const param = {
-                      title: shareObject.title,
-                      desc: shareObject.desc,
-                      share_type: type,
-                      share_url: shareObject.link,
-                      image_url: shareObject.icon,
-                      back: true,
-                      uinType: 0,
-                  };
-                  const callback = function () {
-                      var _a;
-                      (_a = shareObject.callback) === null || _a === void 0 ? void 0 : _a.call(shareObject); // alert(result.retCode);
-                  };
-                  // eslint-disable-next-line no-undef
-                  window.mqq.ui.shareMessage(param, callback);
-              }
+          const source = MQQ_SOURCE;
+          const featureId = FEATURE_IDS.DEFAULT;
+          const shareDataType = libExports.ShareDataType.ark;
+          const commonMsg = {
+              title: shareObject.title || '',
+              desc: shareObject.desc || '',
+              shareUrl: shareObject.link || window.location.href,
+              imageUrl: shareObject.icon || '',
+          };
+          const shareData = {
+              source,
+              featureId,
+              shareDataType,
+              commonMsg,
+          };
+          // 已 init 过
+          if (hasInitQQShare) {
+              libExports.setCustomizeData(shareData);
+              return;
+          }
+          // 初次 init
+          hasInitQQShare = true;
+          libExports.init({
+              source,
+              featureId,
+              shareData,
           });
       });
   }