@jsenv/plugin-transpilation 1.0.0

package/src/babel/babel_helper_directory/babel_helpers/iterableToArrayLimit/iterableToArrayLimit.js

@@ -0,0 +1,54 @@
+/* @minVersion 7.0.0-beta.0 */
+
+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
+  // _x = _next
+  // _r = _return
+
+  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, _x, _r;
+  try {
+    _x = (_i = _i.call(arr)).next;
+    if (i === 0) {
+      if (Object(_i) !== _i) return;
+      _n = false;
+    } else {
+      for (; !(_n = (_s = _x.call(_i)).done); _n = true) {
+        _arr.push(_s.value);
+        if (_arr.length === i) break;
+      }
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) {
+        _r = _i["return"]();
+        // eslint-disable-next-line no-unsafe-finally
+        if (Object(_r) !== _r) return;
+      }
+    } finally {
+      // eslint-disable-next-line no-unsafe-finally
+      if (_d) throw _e;
+    }
+  }
+  return _arr;
+}

package/src/babel/babel_helper_directory/babel_helpers/iterableToArrayLimitLoose/iterableToArrayLimitLoose.js

@@ -0,0 +1,16 @@
+/* @minVersion 7.0.0-beta.0 */
+
+export default function _iterableToArrayLimitLoose(arr, i) {
+  var _i =
+    arr &&
+    ((typeof Symbol !== "undefined" && arr[Symbol.iterator]) ||
+      arr["@@iterator"]);
+  if (_i == null) return;
+
+  var _arr = [];
+  var _s;
+  for (_i = _i.call(arr); arr.length < i && !(_s = _i.next()).done; ) {
+    _arr.push(_s.value);
+  }
+  return _arr;
+}

package/src/babel/babel_helper_directory/babel_helpers/jsx/jsx.js

@@ -0,0 +1,50 @@
+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/src/babel/babel_helper_directory/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/src/babel/babel_helper_directory/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/src/babel/babel_helper_directory/babel_helpers/nonIterableRest/nonIterableRest.js

@@ -0,0 +1,5 @@
+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/src/babel/babel_helper_directory/babel_helpers/nonIterableSpread/nonIterableSpread.js

@@ -0,0 +1,5 @@
+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/src/babel/babel_helper_directory/babel_helpers/objectDestructuringEmpty/objectDestructuringEmpty.js

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

package/src/babel/babel_helper_directory/babel_helpers/objectSpread/objectSpread.js

@@ -0,0 +1,23 @@
+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/src/babel/babel_helper_directory/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/src/babel/babel_helper_directory/babel_helpers/objectWithoutProperties/objectWithoutProperties.js

@@ -0,0 +1,19 @@
+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/src/babel/babel_helper_directory/babel_helpers/objectWithoutPropertiesLoose/objectWithoutPropertiesLoose.js

@@ -0,0 +1,13 @@
+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/src/babel/babel_helper_directory/babel_helpers/overloadYield/overloadYield.js

@@ -0,0 +1,11 @@
+/* @minVersion 7.18.14 */
+
+/*
+ * 'kind' is an enum:
+ *   0 => This yield was an await expression
+ *   1 => This yield comes from yield*
+ */
+export default function _OverloadYield(value, kind) {
+  this.v = value;
+  this.k = kind;
+}

package/src/babel/babel_helper_directory/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/src/babel/babel_helper_directory/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")
+}