index.js 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761
  1. module.exports = (function() {
  2. var __MODS__ = {};
  3. var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; };
  4. var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; };
  5. var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } };
  6. var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; };
  7. __DEFINE__(1658993502784, function(require, module, exports) {
  8. /**
  9. * Copyright (c) 2014-present, Facebook, Inc.
  10. *
  11. * This source code is licensed under the MIT license found in the
  12. * LICENSE file in the root directory of this source tree.
  13. */
  14. var runtime = (function (exports) {
  15. var Op = Object.prototype;
  16. var hasOwn = Op.hasOwnProperty;
  17. var undefined; // More compressible than void 0.
  18. var $Symbol = typeof Symbol === "function" ? Symbol : {};
  19. var iteratorSymbol = $Symbol.iterator || "@@iterator";
  20. var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
  21. var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
  22. function define(obj, key, value) {
  23. Object.defineProperty(obj, key, {
  24. value: value,
  25. enumerable: true,
  26. configurable: true,
  27. writable: true
  28. });
  29. return obj[key];
  30. }
  31. try {
  32. // IE 8 has a broken Object.defineProperty that only works on DOM objects.
  33. define({}, "");
  34. } catch (err) {
  35. define = function(obj, key, value) {
  36. return obj[key] = value;
  37. };
  38. }
  39. function wrap(innerFn, outerFn, self, tryLocsList) {
  40. // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
  41. var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
  42. var generator = Object.create(protoGenerator.prototype);
  43. var context = new Context(tryLocsList || []);
  44. // The ._invoke method unifies the implementations of the .next,
  45. // .throw, and .return methods.
  46. generator._invoke = makeInvokeMethod(innerFn, self, context);
  47. return generator;
  48. }
  49. exports.wrap = wrap;
  50. // Try/catch helper to minimize deoptimizations. Returns a completion
  51. // record like context.tryEntries[i].completion. This interface could
  52. // have been (and was previously) designed to take a closure to be
  53. // invoked without arguments, but in all the cases we care about we
  54. // already have an existing method we want to call, so there's no need
  55. // to create a new function object. We can even get away with assuming
  56. // the method takes exactly one argument, since that happens to be true
  57. // in every case, so we don't have to touch the arguments object. The
  58. // only additional allocation required is the completion record, which
  59. // has a stable shape and so hopefully should be cheap to allocate.
  60. function tryCatch(fn, obj, arg) {
  61. try {
  62. return { type: "normal", arg: fn.call(obj, arg) };
  63. } catch (err) {
  64. return { type: "throw", arg: err };
  65. }
  66. }
  67. var GenStateSuspendedStart = "suspendedStart";
  68. var GenStateSuspendedYield = "suspendedYield";
  69. var GenStateExecuting = "executing";
  70. var GenStateCompleted = "completed";
  71. // Returning this object from the innerFn has the same effect as
  72. // breaking out of the dispatch switch statement.
  73. var ContinueSentinel = {};
  74. // Dummy constructor functions that we use as the .constructor and
  75. // .constructor.prototype properties for functions that return Generator
  76. // objects. For full spec compliance, you may wish to configure your
  77. // minifier not to mangle the names of these two functions.
  78. function Generator() {}
  79. function GeneratorFunction() {}
  80. function GeneratorFunctionPrototype() {}
  81. // This is a polyfill for %IteratorPrototype% for environments that
  82. // don't natively support it.
  83. var IteratorPrototype = {};
  84. IteratorPrototype[iteratorSymbol] = function () {
  85. return this;
  86. };
  87. var getProto = Object.getPrototypeOf;
  88. var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  89. if (NativeIteratorPrototype &&
  90. NativeIteratorPrototype !== Op &&
  91. hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
  92. // This environment has a native %IteratorPrototype%; use it instead
  93. // of the polyfill.
  94. IteratorPrototype = NativeIteratorPrototype;
  95. }
  96. var Gp = GeneratorFunctionPrototype.prototype =
  97. Generator.prototype = Object.create(IteratorPrototype);
  98. GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
  99. GeneratorFunctionPrototype.constructor = GeneratorFunction;
  100. GeneratorFunction.displayName = define(
  101. GeneratorFunctionPrototype,
  102. toStringTagSymbol,
  103. "GeneratorFunction"
  104. );
  105. // Helper for defining the .next, .throw, and .return methods of the
  106. // Iterator interface in terms of a single ._invoke method.
  107. function defineIteratorMethods(prototype) {
  108. ["next", "throw", "return"].forEach(function(method) {
  109. define(prototype, method, function(arg) {
  110. return this._invoke(method, arg);
  111. });
  112. });
  113. }
  114. exports.isGeneratorFunction = function(genFun) {
  115. var ctor = typeof genFun === "function" && genFun.constructor;
  116. return ctor
  117. ? ctor === GeneratorFunction ||
  118. // For the native GeneratorFunction constructor, the best we can
  119. // do is to check its .name property.
  120. (ctor.displayName || ctor.name) === "GeneratorFunction"
  121. : false;
  122. };
  123. exports.mark = function(genFun) {
  124. if (Object.setPrototypeOf) {
  125. Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
  126. } else {
  127. genFun.__proto__ = GeneratorFunctionPrototype;
  128. define(genFun, toStringTagSymbol, "GeneratorFunction");
  129. }
  130. genFun.prototype = Object.create(Gp);
  131. return genFun;
  132. };
  133. // Within the body of any async function, `await x` is transformed to
  134. // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
  135. // `hasOwn.call(value, "__await")` to determine if the yielded value is
  136. // meant to be awaited.
  137. exports.awrap = function(arg) {
  138. return { __await: arg };
  139. };
  140. function AsyncIterator(generator, PromiseImpl) {
  141. function invoke(method, arg, resolve, reject) {
  142. var record = tryCatch(generator[method], generator, arg);
  143. if (record.type === "throw") {
  144. reject(record.arg);
  145. } else {
  146. var result = record.arg;
  147. var value = result.value;
  148. if (value &&
  149. typeof value === "object" &&
  150. hasOwn.call(value, "__await")) {
  151. return PromiseImpl.resolve(value.__await).then(function(value) {
  152. invoke("next", value, resolve, reject);
  153. }, function(err) {
  154. invoke("throw", err, resolve, reject);
  155. });
  156. }
  157. return PromiseImpl.resolve(value).then(function(unwrapped) {
  158. // When a yielded Promise is resolved, its final value becomes
  159. // the .value of the Promise<{value,done}> result for the
  160. // current iteration.
  161. result.value = unwrapped;
  162. resolve(result);
  163. }, function(error) {
  164. // If a rejected Promise was yielded, throw the rejection back
  165. // into the async generator function so it can be handled there.
  166. return invoke("throw", error, resolve, reject);
  167. });
  168. }
  169. }
  170. var previousPromise;
  171. function enqueue(method, arg) {
  172. function callInvokeWithMethodAndArg() {
  173. return new PromiseImpl(function(resolve, reject) {
  174. invoke(method, arg, resolve, reject);
  175. });
  176. }
  177. return previousPromise =
  178. // If enqueue has been called before, then we want to wait until
  179. // all previous Promises have been resolved before calling invoke,
  180. // so that results are always delivered in the correct order. If
  181. // enqueue has not been called before, then it is important to
  182. // call invoke immediately, without waiting on a callback to fire,
  183. // so that the async generator function has the opportunity to do
  184. // any necessary setup in a predictable way. This predictability
  185. // is why the Promise constructor synchronously invokes its
  186. // executor callback, and why async functions synchronously
  187. // execute code before the first await. Since we implement simple
  188. // async functions in terms of async generators, it is especially
  189. // important to get this right, even though it requires care.
  190. previousPromise ? previousPromise.then(
  191. callInvokeWithMethodAndArg,
  192. // Avoid propagating failures to Promises returned by later
  193. // invocations of the iterator.
  194. callInvokeWithMethodAndArg
  195. ) : callInvokeWithMethodAndArg();
  196. }
  197. // Define the unified helper method that is used to implement .next,
  198. // .throw, and .return (see defineIteratorMethods).
  199. this._invoke = enqueue;
  200. }
  201. defineIteratorMethods(AsyncIterator.prototype);
  202. AsyncIterator.prototype[asyncIteratorSymbol] = function () {
  203. return this;
  204. };
  205. exports.AsyncIterator = AsyncIterator;
  206. // Note that simple async functions are implemented on top of
  207. // AsyncIterator objects; they just return a Promise for the value of
  208. // the final result produced by the iterator.
  209. exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
  210. if (PromiseImpl === void 0) PromiseImpl = Promise;
  211. var iter = new AsyncIterator(
  212. wrap(innerFn, outerFn, self, tryLocsList),
  213. PromiseImpl
  214. );
  215. return exports.isGeneratorFunction(outerFn)
  216. ? iter // If outerFn is a generator, return the full iterator.
  217. : iter.next().then(function(result) {
  218. return result.done ? result.value : iter.next();
  219. });
  220. };
  221. function makeInvokeMethod(innerFn, self, context) {
  222. var state = GenStateSuspendedStart;
  223. return function invoke(method, arg) {
  224. if (state === GenStateExecuting) {
  225. throw new Error("Generator is already running");
  226. }
  227. if (state === GenStateCompleted) {
  228. if (method === "throw") {
  229. throw arg;
  230. }
  231. // Be forgiving, per 25.3.3.3.3 of the spec:
  232. // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
  233. return doneResult();
  234. }
  235. context.method = method;
  236. context.arg = arg;
  237. while (true) {
  238. var delegate = context.delegate;
  239. if (delegate) {
  240. var delegateResult = maybeInvokeDelegate(delegate, context);
  241. if (delegateResult) {
  242. if (delegateResult === ContinueSentinel) continue;
  243. return delegateResult;
  244. }
  245. }
  246. if (context.method === "next") {
  247. // Setting context._sent for legacy support of Babel's
  248. // function.sent implementation.
  249. context.sent = context._sent = context.arg;
  250. } else if (context.method === "throw") {
  251. if (state === GenStateSuspendedStart) {
  252. state = GenStateCompleted;
  253. throw context.arg;
  254. }
  255. context.dispatchException(context.arg);
  256. } else if (context.method === "return") {
  257. context.abrupt("return", context.arg);
  258. }
  259. state = GenStateExecuting;
  260. var record = tryCatch(innerFn, self, context);
  261. if (record.type === "normal") {
  262. // If an exception is thrown from innerFn, we leave state ===
  263. // GenStateExecuting and loop back for another invocation.
  264. state = context.done
  265. ? GenStateCompleted
  266. : GenStateSuspendedYield;
  267. if (record.arg === ContinueSentinel) {
  268. continue;
  269. }
  270. return {
  271. value: record.arg,
  272. done: context.done
  273. };
  274. } else if (record.type === "throw") {
  275. state = GenStateCompleted;
  276. // Dispatch the exception by looping back around to the
  277. // context.dispatchException(context.arg) call above.
  278. context.method = "throw";
  279. context.arg = record.arg;
  280. }
  281. }
  282. };
  283. }
  284. // Call delegate.iterator[context.method](context.arg) and handle the
  285. // result, either by returning a { value, done } result from the
  286. // delegate iterator, or by modifying context.method and context.arg,
  287. // setting context.delegate to null, and returning the ContinueSentinel.
  288. function maybeInvokeDelegate(delegate, context) {
  289. var method = delegate.iterator[context.method];
  290. if (method === undefined) {
  291. // A .throw or .return when the delegate iterator has no .throw
  292. // method always terminates the yield* loop.
  293. context.delegate = null;
  294. if (context.method === "throw") {
  295. // Note: ["return"] must be used for ES3 parsing compatibility.
  296. if (delegate.iterator["return"]) {
  297. // If the delegate iterator has a return method, give it a
  298. // chance to clean up.
  299. context.method = "return";
  300. context.arg = undefined;
  301. maybeInvokeDelegate(delegate, context);
  302. if (context.method === "throw") {
  303. // If maybeInvokeDelegate(context) changed context.method from
  304. // "return" to "throw", let that override the TypeError below.
  305. return ContinueSentinel;
  306. }
  307. }
  308. context.method = "throw";
  309. context.arg = new TypeError(
  310. "The iterator does not provide a 'throw' method");
  311. }
  312. return ContinueSentinel;
  313. }
  314. var record = tryCatch(method, delegate.iterator, context.arg);
  315. if (record.type === "throw") {
  316. context.method = "throw";
  317. context.arg = record.arg;
  318. context.delegate = null;
  319. return ContinueSentinel;
  320. }
  321. var info = record.arg;
  322. if (! info) {
  323. context.method = "throw";
  324. context.arg = new TypeError("iterator result is not an object");
  325. context.delegate = null;
  326. return ContinueSentinel;
  327. }
  328. if (info.done) {
  329. // Assign the result of the finished delegate to the temporary
  330. // variable specified by delegate.resultName (see delegateYield).
  331. context[delegate.resultName] = info.value;
  332. // Resume execution at the desired location (see delegateYield).
  333. context.next = delegate.nextLoc;
  334. // If context.method was "throw" but the delegate handled the
  335. // exception, let the outer generator proceed normally. If
  336. // context.method was "next", forget context.arg since it has been
  337. // "consumed" by the delegate iterator. If context.method was
  338. // "return", allow the original .return call to continue in the
  339. // outer generator.
  340. if (context.method !== "return") {
  341. context.method = "next";
  342. context.arg = undefined;
  343. }
  344. } else {
  345. // Re-yield the result returned by the delegate method.
  346. return info;
  347. }
  348. // The delegate iterator is finished, so forget it and continue with
  349. // the outer generator.
  350. context.delegate = null;
  351. return ContinueSentinel;
  352. }
  353. // Define Generator.prototype.{next,throw,return} in terms of the
  354. // unified ._invoke helper method.
  355. defineIteratorMethods(Gp);
  356. define(Gp, toStringTagSymbol, "Generator");
  357. // A Generator should always return itself as the iterator object when the
  358. // @@iterator function is called on it. Some browsers' implementations of the
  359. // iterator prototype chain incorrectly implement this, causing the Generator
  360. // object to not be returned from this call. This ensures that doesn't happen.
  361. // See https://github.com/facebook/regenerator/issues/274 for more details.
  362. Gp[iteratorSymbol] = function() {
  363. return this;
  364. };
  365. Gp.toString = function() {
  366. return "[object Generator]";
  367. };
  368. function pushTryEntry(locs) {
  369. var entry = { tryLoc: locs[0] };
  370. if (1 in locs) {
  371. entry.catchLoc = locs[1];
  372. }
  373. if (2 in locs) {
  374. entry.finallyLoc = locs[2];
  375. entry.afterLoc = locs[3];
  376. }
  377. this.tryEntries.push(entry);
  378. }
  379. function resetTryEntry(entry) {
  380. var record = entry.completion || {};
  381. record.type = "normal";
  382. delete record.arg;
  383. entry.completion = record;
  384. }
  385. function Context(tryLocsList) {
  386. // The root entry object (effectively a try statement without a catch
  387. // or a finally block) gives us a place to store values thrown from
  388. // locations where there is no enclosing try statement.
  389. this.tryEntries = [{ tryLoc: "root" }];
  390. tryLocsList.forEach(pushTryEntry, this);
  391. this.reset(true);
  392. }
  393. exports.keys = function(object) {
  394. var keys = [];
  395. for (var key in object) {
  396. keys.push(key);
  397. }
  398. keys.reverse();
  399. // Rather than returning an object with a next method, we keep
  400. // things simple and return the next function itself.
  401. return function next() {
  402. while (keys.length) {
  403. var key = keys.pop();
  404. if (key in object) {
  405. next.value = key;
  406. next.done = false;
  407. return next;
  408. }
  409. }
  410. // To avoid creating an additional object, we just hang the .value
  411. // and .done properties off the next function object itself. This
  412. // also ensures that the minifier will not anonymize the function.
  413. next.done = true;
  414. return next;
  415. };
  416. };
  417. function values(iterable) {
  418. if (iterable) {
  419. var iteratorMethod = iterable[iteratorSymbol];
  420. if (iteratorMethod) {
  421. return iteratorMethod.call(iterable);
  422. }
  423. if (typeof iterable.next === "function") {
  424. return iterable;
  425. }
  426. if (!isNaN(iterable.length)) {
  427. var i = -1, next = function next() {
  428. while (++i < iterable.length) {
  429. if (hasOwn.call(iterable, i)) {
  430. next.value = iterable[i];
  431. next.done = false;
  432. return next;
  433. }
  434. }
  435. next.value = undefined;
  436. next.done = true;
  437. return next;
  438. };
  439. return next.next = next;
  440. }
  441. }
  442. // Return an iterator with no values.
  443. return { next: doneResult };
  444. }
  445. exports.values = values;
  446. function doneResult() {
  447. return { value: undefined, done: true };
  448. }
  449. Context.prototype = {
  450. constructor: Context,
  451. reset: function(skipTempReset) {
  452. this.prev = 0;
  453. this.next = 0;
  454. // Resetting context._sent for legacy support of Babel's
  455. // function.sent implementation.
  456. this.sent = this._sent = undefined;
  457. this.done = false;
  458. this.delegate = null;
  459. this.method = "next";
  460. this.arg = undefined;
  461. this.tryEntries.forEach(resetTryEntry);
  462. if (!skipTempReset) {
  463. for (var name in this) {
  464. // Not sure about the optimal order of these conditions:
  465. if (name.charAt(0) === "t" &&
  466. hasOwn.call(this, name) &&
  467. !isNaN(+name.slice(1))) {
  468. this[name] = undefined;
  469. }
  470. }
  471. }
  472. },
  473. stop: function() {
  474. this.done = true;
  475. var rootEntry = this.tryEntries[0];
  476. var rootRecord = rootEntry.completion;
  477. if (rootRecord.type === "throw") {
  478. throw rootRecord.arg;
  479. }
  480. return this.rval;
  481. },
  482. dispatchException: function(exception) {
  483. if (this.done) {
  484. throw exception;
  485. }
  486. var context = this;
  487. function handle(loc, caught) {
  488. record.type = "throw";
  489. record.arg = exception;
  490. context.next = loc;
  491. if (caught) {
  492. // If the dispatched exception was caught by a catch block,
  493. // then let that catch block handle the exception normally.
  494. context.method = "next";
  495. context.arg = undefined;
  496. }
  497. return !! caught;
  498. }
  499. for (var i = this.tryEntries.length - 1; i >= 0; --i) {
  500. var entry = this.tryEntries[i];
  501. var record = entry.completion;
  502. if (entry.tryLoc === "root") {
  503. // Exception thrown outside of any try block that could handle
  504. // it, so set the completion value of the entire function to
  505. // throw the exception.
  506. return handle("end");
  507. }
  508. if (entry.tryLoc <= this.prev) {
  509. var hasCatch = hasOwn.call(entry, "catchLoc");
  510. var hasFinally = hasOwn.call(entry, "finallyLoc");
  511. if (hasCatch && hasFinally) {
  512. if (this.prev < entry.catchLoc) {
  513. return handle(entry.catchLoc, true);
  514. } else if (this.prev < entry.finallyLoc) {
  515. return handle(entry.finallyLoc);
  516. }
  517. } else if (hasCatch) {
  518. if (this.prev < entry.catchLoc) {
  519. return handle(entry.catchLoc, true);
  520. }
  521. } else if (hasFinally) {
  522. if (this.prev < entry.finallyLoc) {
  523. return handle(entry.finallyLoc);
  524. }
  525. } else {
  526. throw new Error("try statement without catch or finally");
  527. }
  528. }
  529. }
  530. },
  531. abrupt: function(type, arg) {
  532. for (var i = this.tryEntries.length - 1; i >= 0; --i) {
  533. var entry = this.tryEntries[i];
  534. if (entry.tryLoc <= this.prev &&
  535. hasOwn.call(entry, "finallyLoc") &&
  536. this.prev < entry.finallyLoc) {
  537. var finallyEntry = entry;
  538. break;
  539. }
  540. }
  541. if (finallyEntry &&
  542. (type === "break" ||
  543. type === "continue") &&
  544. finallyEntry.tryLoc <= arg &&
  545. arg <= finallyEntry.finallyLoc) {
  546. // Ignore the finally entry if control is not jumping to a
  547. // location outside the try/catch block.
  548. finallyEntry = null;
  549. }
  550. var record = finallyEntry ? finallyEntry.completion : {};
  551. record.type = type;
  552. record.arg = arg;
  553. if (finallyEntry) {
  554. this.method = "next";
  555. this.next = finallyEntry.finallyLoc;
  556. return ContinueSentinel;
  557. }
  558. return this.complete(record);
  559. },
  560. complete: function(record, afterLoc) {
  561. if (record.type === "throw") {
  562. throw record.arg;
  563. }
  564. if (record.type === "break" ||
  565. record.type === "continue") {
  566. this.next = record.arg;
  567. } else if (record.type === "return") {
  568. this.rval = this.arg = record.arg;
  569. this.method = "return";
  570. this.next = "end";
  571. } else if (record.type === "normal" && afterLoc) {
  572. this.next = afterLoc;
  573. }
  574. return ContinueSentinel;
  575. },
  576. finish: function(finallyLoc) {
  577. for (var i = this.tryEntries.length - 1; i >= 0; --i) {
  578. var entry = this.tryEntries[i];
  579. if (entry.finallyLoc === finallyLoc) {
  580. this.complete(entry.completion, entry.afterLoc);
  581. resetTryEntry(entry);
  582. return ContinueSentinel;
  583. }
  584. }
  585. },
  586. "catch": function(tryLoc) {
  587. for (var i = this.tryEntries.length - 1; i >= 0; --i) {
  588. var entry = this.tryEntries[i];
  589. if (entry.tryLoc === tryLoc) {
  590. var record = entry.completion;
  591. if (record.type === "throw") {
  592. var thrown = record.arg;
  593. resetTryEntry(entry);
  594. }
  595. return thrown;
  596. }
  597. }
  598. // The context.catch method must only be called with a location
  599. // argument that corresponds to a known catch block.
  600. throw new Error("illegal catch attempt");
  601. },
  602. delegateYield: function(iterable, resultName, nextLoc) {
  603. this.delegate = {
  604. iterator: values(iterable),
  605. resultName: resultName,
  606. nextLoc: nextLoc
  607. };
  608. if (this.method === "next") {
  609. // Deliberately forget the last sent value so that we don't
  610. // accidentally pass it on to the delegate.
  611. this.arg = undefined;
  612. }
  613. return ContinueSentinel;
  614. }
  615. };
  616. // Regardless of whether this script is executing as a CommonJS module
  617. // or not, return the runtime object so that we can declare the variable
  618. // regeneratorRuntime in the outer scope, which allows this module to be
  619. // injected easily by `bin/regenerator --include-runtime script.js`.
  620. return exports;
  621. }(
  622. // If this script is executing as a CommonJS module, use module.exports
  623. // as the regeneratorRuntime namespace. Otherwise create a new empty
  624. // object. Either way, the resulting object will be used to initialize
  625. // the regeneratorRuntime variable at the top of this file.
  626. typeof module === "object" ? module.exports : {}
  627. ));
  628. try {
  629. regeneratorRuntime = runtime;
  630. } catch (accidentalStrictMode) {
  631. // This module should not be running in strict mode, so the above
  632. // assignment should always work unless something is misconfigured. Just
  633. // in case runtime.js accidentally runs in strict mode, we can escape
  634. // strict mode using a global Function call. This could conceivably fail
  635. // if a Content Security Policy forbids using Function, but in that case
  636. // the proper solution is to fix the accidental strict mode problem. If
  637. // you've misconfigured your bundler to force strict mode and applied a
  638. // CSP to forbid Function, and you're not willing to fix either of those
  639. // problems, please detail your unique predicament in a GitHub issue.
  640. Function("r", "regeneratorRuntime = r")(runtime);
  641. }
  642. }, function(modId) {var map = {}; return __REQUIRE__(map[modId], modId); })
  643. return __REQUIRE__(1658993502784);
  644. })()
  645. //miniprogram-npm-outsideDeps=[]
  646. //# sourceMappingURL=index.js.map