@jsenv/core 27.0.0-alpha.7 → 27.0.0-alpha.72

package/dist/babel_helpers/AsyncGenerator/AsyncGenerator.js

@@ -0,0 +1,95 @@
+import AwaitValue from "../AwaitValue/AwaitValue.js";
+export default function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume(key === "return" ? "return" : "next", arg);
+          return;
+        }
+
+        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
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send; // Hide "return" method if generator return is not supported
+
+  if (typeof gen.return !== "function") {
+    this.return = undefined;
+  }
+}
+
+AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () {
+  return this;
+};
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype.throw = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype.return = function (arg) {
+  return this._invoke("return", arg);
+};

package/dist/babel_helpers/AwaitValue/AwaitValue.js

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

package/dist/babel_helpers/applyDecoratorDescriptor/applyDecoratorDescriptor.js

@@ -0,0 +1,29 @@
+/* eslint-disable no-void */
+export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object.keys(descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = Boolean(desc.enumerable);
+  desc.configurable = Boolean(desc.configurable);
+
+  if ("value" in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  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 (desc.initializer === void 0) {
+    Object.defineProperty(target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}

package/dist/babel_helpers/arrayLikeToArray/arrayLikeToArray.js

@@ -0,0 +1,9 @@
+/* eslint-disable no-eq-null, eqeqeq */
+export default function arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  var arr2 = new Array(len);
+
+  for (var i = 0; i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}

package/dist/babel_helpers/arrayWithHoles/arrayWithHoles.js

@@ -0,0 +1,4 @@
+// eslint-disable-next-line consistent-return
+export default (arr => {
+  if (Array.isArray(arr)) return arr;
+});

package/dist/babel_helpers/arrayWithoutHoles/arrayWithoutHoles.js

@@ -0,0 +1,5 @@
+import arrayLikeToArray from "../arrayLikeToArray/arrayLikeToArray.js"; // eslint-disable-next-line consistent-return
+
+export default (arr => {
+  if (Array.isArray(arr)) return arrayLikeToArray(arr);
+});

package/dist/babel_helpers/assertThisInitialized/assertThisInitialized.js

@@ -0,0 +1,8 @@
+export default (self => {
+  // eslint-disable-next-line no-void
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+});

package/dist/babel_helpers/asyncGeneratorDelegate/asyncGeneratorDelegate.js

@@ -0,0 +1,52 @@
+export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  iter[typeof Symbol !== "undefined" && Symbol.iterator || "@@iterator"] = function () {
+    return this;
+  };
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner.throw === "function") {
+    iter.throw = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner.return === "function") {
+    iter.return = function (value) {
+      if (waiting) {
+        waiting = false;
+        return value;
+      }
+
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}

package/dist/babel_helpers/asyncIterator/asyncIterator.js

@@ -0,0 +1,78 @@
+export default function _asyncIterator(iterable) {
+  var method,
+      async,
+      sync,
+      retry = 2;
+
+  if (typeof Symbol !== "undefined") {
+    async = Symbol.asyncIterator;
+    sync = Symbol.iterator;
+  }
+
+  while (retry--) {
+    if (async && (method = iterable[async]) != null) {
+      return method.call(iterable);
+    }
+
+    if (sync && (method = iterable[sync]) != null) {
+      return new AsyncFromSyncIterator(method.call(iterable));
+    }
+
+    async = "@@asyncIterator";
+    sync = "@@iterator";
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
+
+function AsyncFromSyncIterator(s) {
+  AsyncFromSyncIterator = function (s) {
+    this.s = s;
+    this.n = s.next;
+  };
+
+  AsyncFromSyncIterator.prototype = {
+    /* SyncIterator */
+    s: null,
+
+    /* SyncIterator.[[Next]] */
+    n: null,
+    next: function () {
+      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+    },
+    return: function (value) {
+      var ret = this.s.return;
+
+      if (ret === undefined) {
+        return Promise.resolve({
+          value: value,
+          done: true
+        });
+      }
+
+      return AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+    },
+    throw: function (value) {
+      var thr = this.s.return;
+      if (thr === undefined) return Promise.reject(value);
+      return AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+    }
+  };
+
+  function AsyncFromSyncIteratorContinuation(r) {
+    // This step is _before_ calling AsyncFromSyncIteratorContinuation in the spec.
+    if (Object(r) !== r) {
+      return Promise.reject(new TypeError(r + " is not an object."));
+    }
+
+    var done = r.done;
+    return Promise.resolve(r.value).then(function (value) {
+      return {
+        value: value,
+        done: done
+      };
+    });
+  }
+
+  return new AsyncFromSyncIterator(s);
+}

package/dist/babel_helpers/asyncToGenerator/asyncToGenerator.js

@@ -0,0 +1,39 @@
+export default function (fn) {
+  return function () {
+    var self = this; // eslint-disable-next-line prefer-rest-params
+
+    var args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+const asyncGeneratorStep = (gen, resolve, reject, _next, _throw, key, arg) => {
+  var info;
+  var value;
+
+  try {
+    info = gen[key](arg);
+    value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+};

package/dist/babel_helpers/awaitAsyncGenerator/awaitAsyncGenerator.js

@@ -0,0 +1,4 @@
+import AwaitValue from "../AwaitValue/AwaitValue.js";
+export default function (value) {
+  return new AwaitValue(value);
+}

package/dist/babel_helpers/classApplyDescriptorDestructureSet/classApplyDescriptorDestructureSet.js

@@ -0,0 +1,24 @@
+export default function _classApplyDescriptorDestructureSet(receiver, descriptor) {
+  if (descriptor.set) {
+    if (!("__destrObj" in descriptor)) {
+      descriptor.__destrObj = {
+        // eslint-disable-next-line accessor-pairs
+        set value(v) {
+          descriptor.set.call(receiver, v);
+        }
+
+      };
+    }
+
+    return descriptor.__destrObj;
+  }
+
+  if (!descriptor.writable) {
+    // This should only throw in strict mode, but class bodies are
+    // always strict and private fields can only be used inside
+    // class bodies.
+    throw new TypeError("attempted to set read only private field");
+  }
+
+  return descriptor;
+}

package/dist/babel_helpers/classApplyDescriptorGet/classApplyDescriptorGet.js

@@ -0,0 +1,7 @@
+export default function _classApplyDescriptorGet(receiver, descriptor) {
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}

package/dist/babel_helpers/classApplyDescriptorSet/classApplyDescriptorSet.js

@@ -0,0 +1,14 @@
+export default function _classApplyDescriptorSet(receiver, descriptor, value) {
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      // This should only throw in strict mode, but class bodies are
+      // always strict and private fields can only be used inside
+      // class bodies.
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    descriptor.value = value;
+  }
+}

package/dist/babel_helpers/classCallCheck/classCallCheck.js

@@ -0,0 +1,5 @@
+export default function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}

package/dist/babel_helpers/classCheckPrivateStaticAccess/classCheckPrivateStaticAccess.js

@@ -0,0 +1,5 @@
+export default function _classCheckPrivateStaticAccess(receiver, classConstructor) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+}

package/dist/babel_helpers/classCheckPrivateStaticFieldDescriptor/classCheckPrivateStaticFieldDescriptor.js

@@ -0,0 +1,6 @@
+export default function _classCheckPrivateStaticFieldDescriptor(descriptor, action) {
+  if (descriptor === undefined) {
+    // eslint-disable-next-line prefer-template
+    throw new TypeError("attempted to " + action + " private static field before its declaration");
+  }
+}

package/dist/babel_helpers/classExtractFieldDescriptor/classExtractFieldDescriptor.js

@@ -0,0 +1,8 @@
+export default function _classExtractFieldDescriptor(receiver, privateMap, action) {
+  if (!privateMap.has(receiver)) {
+    // eslint-disable-next-line prefer-template
+    throw new TypeError("attempted to " + action + " private field on non-instance");
+  }
+
+  return privateMap.get(receiver);
+}

package/dist/babel_helpers/classNameTDZError/classNameTDZError.js

@@ -0,0 +1,4 @@
+export default function _classNameTDZError(name) {
+  // eslint-disable-next-line prefer-template
+  throw new Error("Class " + name + "cannot be referenced in computed property keys.");
+}

package/dist/babel_helpers/classPrivateFieldDestructureSet/classPrivateFieldDestructureSet.js

@@ -0,0 +1,6 @@
+import classApplyDescriptorDestructureSet from "../classApplyDescriptorDestructureSet/classApplyDescriptorDestructureSet.js";
+import classExtractFieldDescriptor from "../classExtractFieldDescriptor/classExtractFieldDescriptor.js";
+export default function (receiver, privateMap) {
+  var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
+  return classApplyDescriptorDestructureSet(receiver, descriptor);
+}

package/dist/babel_helpers/classPrivateFieldGet/classPrivateFieldGet.js

@@ -0,0 +1,6 @@
+import classApplyDescriptorGet from "../classApplyDescriptorGet/classApplyDescriptorGet.js";
+import classExtractFieldDescriptor from "../classExtractFieldDescriptor/classExtractFieldDescriptor.js";
+export default function (receiver, privateMap) {
+  var descriptor = classExtractFieldDescriptor(receiver, privateMap, "get");
+  return classApplyDescriptorGet(receiver, descriptor);
+}

package/dist/babel_helpers/classPrivateFieldLooseBase/classPrivateFieldLooseBase.js

@@ -0,0 +1,7 @@
+export default function (receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+
+  return receiver;
+}

package/dist/babel_helpers/classPrivateFieldLooseKey/classPrivateFieldLooseKey.js

@@ -0,0 +1,5 @@
+var id = 0;
+export default function (name) {
+  // eslint-disable-next-line prefer-template
+  return "__private_" + id++ + "_" + name;
+}

package/dist/babel_helpers/classPrivateFieldSet/classPrivateFieldSet.js

@@ -0,0 +1,7 @@
+import classApplyDescriptorSet from "../classApplyDescriptorSet/classApplyDescriptorSet.js";
+import classExtractFieldDescriptor from "../classExtractFieldDescriptor/classExtractFieldDescriptor.js";
+export default function (receiver, privateMap, value) {
+  var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
+  classApplyDescriptorSet(receiver, descriptor, value);
+  return value;
+}

package/dist/babel_helpers/classPrivateMethodGet/classPrivateMethodGet.js

@@ -0,0 +1,7 @@
+export default function _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  return fn;
+}

package/dist/babel_helpers/classPrivateMethodSet/classPrivateMethodSet.js

@@ -0,0 +1,3 @@
+export default function _classStaticPrivateMethodSet() {
+  throw new TypeError("attempted to set read only static private field");
+}

package/dist/babel_helpers/classStaticPrivateFieldSpecGet/classStaticPrivateFieldSpecGet.js

@@ -0,0 +1,8 @@
+import classApplyDescriptorGet from "../classApplyDescriptorGet/classApplyDescriptorGet.js";
+import classCheckPrivateStaticAccess from "../classCheckPrivateStaticAccess/classCheckPrivateStaticAccess.js";
+import classCheckPrivateStaticFieldDescriptor from "../classCheckPrivateStaticFieldDescriptor/classCheckPrivateStaticFieldDescriptor.js";
+export default function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
+  classCheckPrivateStaticAccess(receiver, classConstructor);
+  classCheckPrivateStaticFieldDescriptor(descriptor, "get");
+  return classApplyDescriptorGet(receiver, descriptor);
+}

package/dist/babel_helpers/classStaticPrivateFieldSpecSet/classStaticPrivateFieldSpecSet.js

@@ -0,0 +1,9 @@
+import classApplyDescriptorSet from "../classApplyDescriptorSet/classApplyDescriptorSet.js";
+import classCheckPrivateStaticAccess from "../classCheckPrivateStaticAccess/classCheckPrivateStaticAccess.js";
+import classCheckPrivateStaticFieldDescriptor from "../classCheckPrivateStaticFieldDescriptor/classCheckPrivateStaticFieldDescriptor.js";
+export default function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
+  classCheckPrivateStaticAccess(receiver, classConstructor);
+  classCheckPrivateStaticFieldDescriptor(descriptor, "set");
+  classApplyDescriptorSet(receiver, descriptor, value);
+  return value;
+}

package/dist/babel_helpers/classStaticPrivateMethodGet/classStaticPrivateMethodGet.js

@@ -0,0 +1,5 @@
+import classCheckPrivateStaticAccess from "../classCheckPrivateStaticAccess/classCheckPrivateStaticAccess.js";
+export default function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
+  classCheckPrivateStaticAccess(receiver, classConstructor);
+  return method;
+}

package/dist/babel_helpers/classStaticPrivateMethodSet/classStaticPrivateMethodSet.js

@@ -0,0 +1,3 @@
+export default function _classStaticPrivateMethodSet() {
+  throw new TypeError("attempted to set read only static private field");
+}

package/dist/babel_helpers/construct/construct.js

@@ -0,0 +1,15 @@
+import setPrototypeOf from "../setPrototypeOf/setPrototypeOf.js";
+import isNativeReflectConstruct from "../isNativeReflectConstruct/isNativeReflectConstruct.js"; // NOTE: If Parent !== Class, the correct __proto__ is set *after*
+// calling the constructor.
+
+function reflectConstruct(Parent, args, Class) {
+  var a = [null]; // eslint-disable-next-line prefer-spread
+
+  a.push.apply(a, args);
+  var Constructor = Function.bind.apply(Parent, a);
+  var instance = new Constructor();
+  if (Class) setPrototypeOf(instance, Class.prototype);
+  return instance;
+}
+
+export default isNativeReflectConstruct() ? Reflect.construct : reflectConstruct;

package/dist/babel_helpers/createClass/createClass.js

@@ -0,0 +1,18 @@
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+export default function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}

package/dist/babel_helpers/createForOfIteratorHelper/createForOfIteratorHelper.js

@@ -0,0 +1,63 @@
+/* eslint-disable eqeqeq, no-eq-null */
+import unsupportedIterableToArray from "../unsupportedIterableToArray/unsupportedIterableToArray.js"; // s: start (create the iterator)
+// n: next
+// e: error (called whenever something throws)
+// f: finish (always called at the end)
+
+export default function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+  if (!it) {
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+
+      var F = function () {};
+
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  var normalCompletion = true,
+      didErr = false,
+      err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}

package/dist/babel_helpers/createForOfIteratorHelperLoose/createForOfIteratorHelperLoose.js

@@ -0,0 +1,22 @@
+/* eslint-disable eqeqeq, no-eq-null */
+import unsupportedIterableToArray from "../unsupportedIterableToArray/unsupportedIterableToArray.js";
+export default function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it); // Fallback for engines without symbol support
+
+  if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}