@jsenv/core 27.0.0-alpha.8 → 27.0.0-alpha.82

package/dist/babel_helpers/get/get.js

@@ -0,0 +1,21 @@
+import superPropBase from "../superPropBase/superPropBase.js";
+export default function _get() {
+  if (typeof Reflect !== "undefined" && Reflect.get) {
+    _get = Reflect.get.bind();
+  } else {
+    _get = function _get(target, property, receiver) {
+      var base = superPropBase(target, property);
+      if (!base) return;
+      var desc = Object.getOwnPropertyDescriptor(base, property);
+
+      if (desc.get) {
+        // STEP 3. If receiver is not present, then set receiver to target.
+        return desc.get.call(arguments.length < 3 ? target : receiver);
+      }
+
+      return desc.value;
+    };
+  }
+
+  return _get.apply(this, arguments);
+}

package/dist/babel_helpers/getPrototypeOf/getPrototypeOf.js

@@ -0,0 +1,2 @@
+export default Object.setPrototypeOf ? Object.getPrototypeOf.bind() : // eslint-disable-next-line no-proto
+o => o.__proto__ || Object.getPrototypeOf(o);

package/dist/babel_helpers/identity/identity.js

@@ -0,0 +1,3 @@
+export default function _identity(x) {
+  return x;
+}

package/dist/babel_helpers/inherits/inherits.js

@@ -0,0 +1,21 @@
+import setPrototypeOf from "../setPrototypeOf/setPrototypeOf.js";
+export default function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  } // We can't use defineProperty to set the prototype in a single step because it
+  // doesn't work in Chrome <= 36. https://github.com/babel/babel/issues/14056
+  // V8 bug: https://bugs.chromium.org/p/v8/issues/detail?id=3334
+
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) setPrototypeOf(subClass, superClass);
+}

package/dist/babel_helpers/inheritsLoose/inheritsLoose.js

@@ -0,0 +1,6 @@
+import setPrototypeOf from "../setPrototypeOf/setPrototypeOf.js";
+export default function (subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  setPrototypeOf(subClass, superClass);
+}

package/dist/babel_helpers/initializerDefineProperty/initializerDefineProperty.js

@@ -0,0 +1,10 @@
+export default function (target, property, descriptor, context) {
+  if (!descriptor) return;
+  Object.defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    // eslint-disable-next-line no-void
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}

package/dist/babel_helpers/initializerWarningHelper/initializerWarningHelper.js

@@ -0,0 +1,3 @@
+export default function () {
+  throw new Error("Decorating class property failed. Please ensure that " + "proposal-class-properties is enabled and runs after the decorators transform.");
+}

package/dist/babel_helpers/instanceof/instanceof.js

@@ -0,0 +1,7 @@
+export default function (left, right) {
+  if (right !== null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return Boolean(right[Symbol.hasInstance](left));
+  }
+
+  return left instanceof right;
+}

package/dist/babel_helpers/interopRequireDefault/interopRequireDefault.js

@@ -0,0 +1,5 @@
+export default function (obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}

package/dist/babel_helpers/interopRequireWildcard/interopRequireWildcard.js

@@ -0,0 +1,49 @@
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+export default function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    return {
+      default: obj
+    };
+  }
+
+  var cache = _getRequireWildcardCache(nodeInterop);
+
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+
+  newObj.default = obj;
+
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+
+  return newObj;
+}

package/dist/babel_helpers/isNativeFunction/isNativeFunction.js

@@ -0,0 +1,4 @@
+// Note: This function returns "true" for core-js functions.
+export default function (fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}

package/dist/babel_helpers/isNativeReflectConstruct/isNativeReflectConstruct.js

@@ -0,0 +1,21 @@
+export default function isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false; // core-js@3
+
+  if (Reflect.construct.sham) return false; // Proxy can't be polyfilled. Every browser implemented
+  // proxies before or at the same time as Reflect.construct,
+  // so if they support Proxy they also support Reflect.construct.
+
+  if (typeof Proxy === "function") return true; // Since Reflect.construct can't be properly polyfilled, some
+  // implementations (e.g. core-js@2) don't set the correct internal slots.
+  // Those polyfills don't allow us to subclass built-ins, so we need to
+  // use our fallback implementation.
+
+  try {
+    // If the internal slots aren't set, this throws an error similar to
+    // TypeError: this is not a Boolean object.
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}

package/dist/babel_helpers/iterableToArray/iterableToArray.js

@@ -0,0 +1,3 @@
+export default function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}

package/dist/babel_helpers/iterableToArrayLimit/iterableToArrayLimit.js

@@ -0,0 +1,38 @@
+export default function _iterableToArrayLimit(arr, i) {
+  // this is an expanded form of \`for...of\` that properly supports abrupt completions of
+  // iterators etc. variable names have been minimised to reduce the size of this massive
+  // helper. sometimes spec compliance is annoying :(
+  //
+  // _n = _iteratorNormalCompletion
+  // _d = _didIteratorError
+  // _e = _iteratorError
+  // _i = _iterator
+  // _s = _step
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}

package/dist/babel_helpers/iterableToArrayLimitLoose/iterableToArrayLimitLoose.js

@@ -0,0 +1,13 @@
+export default function (arr, i) {
+  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+  var _arr = [];
+
+  for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+    _arr.push(_step.value);
+
+    if (i && _arr.length === i) break;
+  } // eslint-disable-next-line consistent-return
+
+
+  return _arr;
+}

package/dist/babel_helpers/jsx/jsx.js

@@ -0,0 +1,49 @@
+var REACT_ELEMENT_TYPE;
+export default function _createRawReactElement(type, props, key, children) {
+  if (!REACT_ELEMENT_TYPE) {
+    REACT_ELEMENT_TYPE = typeof Symbol === "function" && // "for" is a reserved keyword in ES3 so escaping it here for backward compatibility
+    Symbol["for"] && Symbol["for"]("react.element") || 0xeac7;
+  }
+
+  var defaultProps = type && type.defaultProps;
+  var childrenLength = arguments.length - 3;
+
+  if (!props && childrenLength !== 0) {
+    // If we're going to assign props.children, we create a new object now
+    // to avoid mutating defaultProps.
+    props = {
+      children: void 0
+    };
+  }
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    var childArray = new Array(childrenLength);
+
+    for (var i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 3];
+    }
+
+    props.children = childArray;
+  }
+
+  if (props && defaultProps) {
+    for (var propName in defaultProps) {
+      if (props[propName] === void 0) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  } else if (!props) {
+    props = defaultProps || {};
+  }
+
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: type,
+    key: key === undefined ? null : "" + key,
+    ref: null,
+    props: props,
+    _owner: null
+  };
+}

package/dist/babel_helpers/maybeArrayLike/maybeArrayLike.js

@@ -0,0 +1,10 @@
+import arrayLikeToArray from "../arrayLikeToArray/arrayLikeToArray.js";
+export default function _maybeArrayLike(next, arr, i) {
+  if (arr && !Array.isArray(arr) && typeof arr.length === "number") {
+    var len = arr.length; // eslint-disable-next-line no-void
+
+    return arrayLikeToArray(arr, i !== void 0 && i < len ? i : len);
+  }
+
+  return next(arr, i);
+}

package/dist/babel_helpers/newArrowCheck/newArrowCheck.js

@@ -0,0 +1,5 @@
+export default function _newArrowCheck(innerThis, boundThis) {
+  if (innerThis !== boundThis) {
+    throw new TypeError("Cannot instantiate an arrow function");
+  }
+}

package/dist/babel_helpers/nonIterableRest/nonIterableRest.js

@@ -0,0 +1,3 @@
+export default (() => {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+});

package/dist/babel_helpers/nonIterableSpread/nonIterableSpread.js

@@ -0,0 +1,3 @@
+export default (() => {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+});

package/dist/babel_helpers/objectDestructuringEmpty/objectDestructuringEmpty.js

@@ -0,0 +1,3 @@
+export default function _objectDestructuringEmpty(obj) {
+  if (obj == null) throw new TypeError("Cannot destructure undefined");
+}

package/dist/babel_helpers/objectSpread/objectSpread.js

@@ -0,0 +1,22 @@
+import defineProperty from "../defineProperty/defineProperty.js";
+export default function (target) {
+  for (var i = 1; i < arguments.length; i++) {
+    // eslint-disable-next-line
+    var source = arguments[i] != null ? Object(arguments[i]) : {};
+    var ownKeys = Object.keys(source);
+
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys.push.apply(ownKeys, // eslint-disable-next-line no-loop-func
+      Object.getOwnPropertySymbols(source).filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    } // eslint-disable-next-line no-loop-func
+
+
+    ownKeys.forEach(function (key) {
+      defineProperty(target, key, source[key]);
+    });
+  }
+
+  return target;
+}

package/dist/babel_helpers/objectSpread2/objectSpread2.js

@@ -0,0 +1,41 @@
+import defineProperty from "../defineProperty/defineProperty.js"; // This function is different to "Reflect.ownKeys". The enumerableOnly
+// filters on symbol properties only. Returned string properties are always
+// enumerable. It is good to use in objectSpread.
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+
+    if (enumerableOnly) {
+      symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+export default function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}

package/dist/babel_helpers/objectWithoutProperties/objectWithoutProperties.js

@@ -0,0 +1,20 @@
+import objectWithoutPropertiesLoose from "../objectWithoutPropertiesLoose/objectWithoutPropertiesLoose.js";
+export default ((source, excluded) => {
+  if (source === null) return {};
+  var target = objectWithoutPropertiesLoose(source, excluded);
+  var key;
+  var i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+});

package/dist/babel_helpers/objectWithoutPropertiesLoose/objectWithoutPropertiesLoose.js

@@ -0,0 +1,15 @@
+export default ((source, excluded) => {
+  if (source === null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key;
+  var i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+});

package/dist/babel_helpers/possibleConstructorReturn/possibleConstructorReturn.js

@@ -0,0 +1,10 @@
+import assertThisInitialized from "../assertThisInitialized/assertThisInitialized.js";
+export default ((self, call) => {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+
+  return assertThisInitialized(self);
+});

package/dist/babel_helpers/readOnlyError/readOnlyError.js

@@ -0,0 +1,4 @@
+export default function (name) {
+  // eslint-disable-next-line prefer-template
+  throw new TypeError(name + " is read-only");
+}

package/dist/babel_helpers/set/set.js

@@ -0,0 +1,51 @@
+import superPropBase from "../superPropBase/superPropBase.js";
+import defineProperty from "../defineProperty/defineProperty.js";
+
+function reflectSetPolyfill(target, property, value, receiver) {
+  var base = superPropBase(target, property);
+  var desc;
+
+  if (base) {
+    desc = Object.getOwnPropertyDescriptor(base, property);
+
+    if (desc.set) {
+      desc.set.call(receiver, value);
+      return true;
+    } else if (!desc.writable) {
+      // Both getter and non-writable fall into this.
+      return false;
+    }
+  } // Without a super that defines the property, spec boils down to
+  // "define on receiver" for some reason.
+
+
+  desc = Object.getOwnPropertyDescriptor(receiver, property);
+
+  if (desc) {
+    if (!desc.writable) {
+      // Setter, getter, and non-writable fall into this.
+      return false;
+    }
+
+    desc.value = value;
+    Object.defineProperty(receiver, property, desc);
+  } else {
+    // Avoid setters that may be defined on Sub's prototype, but not on
+    // the instance.
+    defineProperty(receiver, property, value);
+  }
+
+  return true;
+}
+
+var reflectSet = typeof Reflect !== "undefined" && Reflect.set ? Reflect.set : reflectSetPolyfill;
+export default ((target, property, value, receiver, isStrict) => {
+  // eslint-disable-next-line no-obj-calls
+  var s = reflectSet(target, property, value, receiver || target);
+
+  if (!s && isStrict) {
+    throw new Error("failed to set property");
+  }
+
+  return value;
+});

package/dist/babel_helpers/setPrototypeOf/setPrototypeOf.js

@@ -0,0 +1,5 @@
+export default Object.setPrototypeOf ? Object.setPrototypeOf.bind() : (o, p) => {
+  // eslint-disable-next-line no-proto
+  o.__proto__ = p;
+  return o;
+};

package/dist/babel_helpers/skipFirstGeneratorNext/skipFirstGeneratorNext.js

@@ -0,0 +1,8 @@
+export default function (fn) {
+  return function () {
+    // eslint-disable-next-line prefer-rest-params
+    var it = fn.apply(this, arguments);
+    it.next();
+    return it;
+  };
+}

package/dist/babel_helpers/slicedToArray/slicedToArray.js

@@ -0,0 +1,5 @@
+import arrayWithHoles from "../arrayWithHoles/arrayWithHoles.js";
+import iterableToArrayLimit from "../iterableToArrayLimit/iterableToArrayLimit.js";
+import unsupportedIterableToArray from "../unsupportedIterableToArray/unsupportedIterableToArray.js";
+import nonIterableRest from "../nonIterableRest/nonIterableRest.js";
+export default ((arr, i) => arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest());

package/dist/babel_helpers/slicedToArrayLoose/slicedToArrayLoose.js

@@ -0,0 +1,7 @@
+import arrayWithHoles from "../arrayWithHoles/arrayWithHoles.js";
+import iterableToArrayLimitLoose from "../iterableToArrayLimitLoose/iterableToArrayLimitLoose.js";
+import unsupportedIterableToArray from "../unsupportedIterableToArray/unsupportedIterableToArray.js";
+import nonIterableRest from "../nonIterableRest/nonIterableRest.js";
+export default function (arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}

package/dist/babel_helpers/superPropBase/superPropBase.js

@@ -0,0 +1,10 @@
+import getPrototypeOf from "../getPrototypeOf/getPrototypeOf.js";
+export default function (object, property) {
+  // Yes, this throws if object is null to being with, that's on purpose.
+  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+    object = getPrototypeOf(object);
+    if (object === null) break;
+  }
+
+  return object;
+}

package/dist/babel_helpers/taggedTemplateLiteral/taggedTemplateLiteral.js

@@ -0,0 +1,11 @@
+export default function (strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
+    }
+  }));
+}

package/dist/babel_helpers/taggedTemplateLiteralLoose/taggedTemplateLiteralLoose.js

@@ -0,0 +1,8 @@
+export default function (strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  strings.raw = raw;
+  return strings;
+}

package/dist/babel_helpers/tdz/tdz.js

@@ -0,0 +1,4 @@
+export default function _tdzError(name) {
+  // eslint-disable-next-line prefer-template
+  throw new ReferenceError(name + " is not defined - temporal dead zone");
+}

package/dist/babel_helpers/temporalRef/temporalRef.js

@@ -0,0 +1,5 @@
+import undef from "../temporalUndefined/temporalUndefined.js";
+import err from "../tdz/tdz.js";
+export default function (val, name) {
+  return val === undef ? err(name) : val;
+}

package/dist/babel_helpers/temporalUndefined/temporalUndefined.js

@@ -0,0 +1,3 @@
+// This function isn't mean to be called, but to be used as a reference.
+// We can't use a normal object because it isn't hoisted.
+export default function () {}

package/dist/babel_helpers/toArray/toArray.js

@@ -0,0 +1,5 @@
+import arrayWithHoles from "../arrayWithHoles/arrayWithHoles.js";
+import iterableToArray from "../iterableToArray/iterableToArray.js";
+import unsupportedIterableToArray from "../unsupportedIterableToArray/unsupportedIterableToArray.js";
+import nonIterableRest from "../nonIterableRest/nonIterableRest.js";
+export default (arr => arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest());

package/dist/babel_helpers/toConsumableArray/toConsumableArray.js

@@ -0,0 +1,5 @@
+import arrayWithoutHoles from "../arrayWithoutHoles/arrayWithoutHoles.js";
+import iterableToArray from "../iterableToArray/iterableToArray.js";
+import unsupportedIterableToArray from "../unsupportedIterableToArray/unsupportedIterableToArray.js";
+import nonIterableSpread from "../nonIterableSpread/nonIterableSpread.js";
+export default (arr => arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread());

package/dist/babel_helpers/toPrimitive/toPrimitive.js

@@ -0,0 +1,14 @@
+export default function (input, hint
+/* : "default" | "string" | "number" | void */
+) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+
+  return (hint === "string" ? String : Number)(input);
+}

package/dist/babel_helpers/toPropertyKey/toPropertyKey.js

@@ -0,0 +1,5 @@
+import toPrimitive from "../toPrimitive/toPrimitive.js";
+export default function (arg) {
+  var key = toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}

package/dist/babel_helpers/typeof/typeof.js

@@ -0,0 +1,7 @@
+const nativeTypeOf = obj => typeof obj;
+
+const customTypeOf = obj => {
+  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+};
+
+export default typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? nativeTypeOf : customTypeOf;

package/dist/babel_helpers/unsupportedIterableToArray/unsupportedIterableToArray.js

@@ -0,0 +1,10 @@
+/* eslint-disable consistent-return */
+import arrayLikeToArray from "../arrayLikeToArray/arrayLikeToArray.js";
+export default function unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
+}

package/dist/babel_helpers/wrapAsyncGenerator/wrapAsyncGenerator.js

@@ -0,0 +1,7 @@
+import AsyncGenerator from "../AsyncGenerator/AsyncGenerator.js";
+export default function (fn) {
+  return function () {
+    // eslint-disable-next-line prefer-rest-params
+    return new AsyncGenerator(fn.apply(this, arguments));
+  };
+}