@jsenv/core 36.2.1 → 36.3.0

package/dist/babel_helpers/AsyncGenerator/AsyncGenerator.js

@@ -1,8 +1,10 @@
 /* @minVersion 7.0.0-beta.0 */
 
 import OverloadYield from "../overloadYield/overloadYield.js";
+
 export default function AsyncGenerator(gen) {
   var front, back;
+
   function send(key, arg) {
     return new Promise(function (resolve, reject) {
       var request = {
@@ -10,8 +12,9 @@ export default function AsyncGenerator(gen) {
         arg: arg,
         resolve: resolve,
         reject: reject,
-        next: null
+        next: null,
       };
+
       if (back) {
         back = back.next = request;
       } else {
@@ -20,60 +23,62 @@ export default function AsyncGenerator(gen) {
       }
     });
   }
+
   function resume(key, arg) {
     try {
       var result = gen[key](arg);
       var value = result.value;
       var overloaded = value instanceof OverloadYield;
-      Promise.resolve(overloaded ? value.v : value).then(function (arg) {
-        if (overloaded) {
-          // Overloaded yield requires calling into the generator twice:
-          //  - first we get the iterator result wrapped in a promise
-          //    (the gen[key](arg) call above)
-          //  - then we await it (the Promise.resolve call above)
-          //  - then we give the result back to the iterator, so that it can:
-          //    * if it was an await, use its result
-          //    * if it was a yield*, possibly return the `done: true` signal
-          //      so that yield* knows that the iterator is finished.
-          //      This needs to happen in the second call, because in the
-          //      first one `done: true` was hidden in the promise and thus
-          //      not visible to the (sync) yield*.
-          //      The other part of this implementation is in asyncGeneratorDelegate.
-          var nextKey = key === "return" ? "return" : "next";
-          if (!value.k || arg.done) {
-            // await or end of yield*
-            return resume(nextKey, arg);
-          } else {
-            // yield*, not done
-            arg = gen[nextKey](arg).value;
+
+      Promise.resolve(overloaded ? value.v : value).then(
+        function (arg) {
+          if (overloaded) {
+            // Overloaded yield requires calling into the generator twice:
+            //  - first we get the iterator result wrapped in a promise
+            //    (the gen[key](arg) call above)
+            //  - then we await it (the Promise.resolve call above)
+            //  - then we give the result back to the iterator, so that it can:
+            //    * if it was an await, use its result
+            //    * if it was a yield*, possibly return the `done: true` signal
+            //      so that yield* knows that the iterator is finished.
+            //      This needs to happen in the second call, because in the
+            //      first one `done: true` was hidden in the promise and thus
+            //      not visible to the (sync) yield*.
+            //      The other part of this implementation is in asyncGeneratorDelegate.
+            var nextKey = key === "return" ? "return" : "next";
+            if (!value.k || arg.done) {
+              // await or end of yield*
+              return resume(nextKey, arg);
+            } else {
+              // yield*, not done
+              arg = gen[nextKey](arg).value;
+            }
           }
+
+          settle(result.done ? "return" : "normal", arg);
+        },
+        function (err) {
+          resume("throw", err);
         }
-        settle(result.done ? "return" : "normal", arg);
-      }, function (err) {
-        resume("throw", err);
-      });
+      );
     } catch (err) {
       settle("throw", err);
     }
   }
+
   function settle(type, value) {
     switch (type) {
       case "return":
-        front.resolve({
-          value: value,
-          done: true
-        });
+        front.resolve({ value: value, done: true });
         break;
       case "throw":
         front.reject(value);
         break;
       default:
-        front.resolve({
-          value: value,
-          done: false
-        });
+        front.resolve({ value: value, done: false });
         break;
     }
+
     front = front.next;
     if (front) {
       resume(front.key, front.arg);
@@ -81,6 +86,7 @@ export default function AsyncGenerator(gen) {
       back = null;
     }
   }
+
   this._invoke = send;
 
   // Hide "return" method if generator return is not supported
@@ -88,9 +94,13 @@ export default function AsyncGenerator(gen) {
     this.return = undefined;
   }
 }
-AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () {
+
+AsyncGenerator.prototype[
+  (typeof Symbol === "function" && Symbol.asyncIterator) || "@@asyncIterator"
+] = function () {
   return this;
 };
+
 AsyncGenerator.prototype.next = function (arg) {
   return this._invoke("next", arg);
 };

package/dist/babel_helpers/AwaitValue/AwaitValue.js

@@ -1,3 +1,3 @@
-export default function _AwaitValue(value) {
-  this.wrapped = value;
-}
+export default function _AwaitValue (value) {
+  this.wrapped = value
+}

package/dist/babel_helpers/applyDecoratedDescriptor/applyDecoratedDescriptor.js

@@ -1,23 +1,23 @@
-export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context){
   var desc = {};
-  Object.keys(descriptor).forEach(function (key) {
-    desc[key] = descriptor[key];
+  Object.keys(descriptor).forEach(function(key){
+      desc[key] = descriptor[key];
   });
   desc.enumerable = !!desc.enumerable;
   desc.configurable = !!desc.configurable;
-  if ('value' in desc || desc.initializer) {
-    desc.writable = true;
+  if ('value' in desc || desc.initializer){
+      desc.writable = true;
   }
-  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
-    return decorator(target, property, desc) || desc;
+  desc = decorators.slice().reverse().reduce(function(desc, decorator){
+      return decorator(target, property, desc) || desc;
   }, desc);
-  if (context && desc.initializer !== void 0) {
-    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
-    desc.initializer = undefined;
+  if (context && desc.initializer !== void 0){
+      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+      desc.initializer = undefined;
   }
-  if (desc.initializer === void 0) {
-    Object.defineProperty(target, property, desc);
-    desc = null;
+  if (desc.initializer === void 0){
+      Object.defineProperty(target, property, desc);
+      desc = null;
   }
   return desc;
 }