@jsenv/core 27.0.0-alpha.64 → 27.0.0-alpha.67

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));
+  };
+}

package/dist/babel_helpers/wrapNativeSuper/wrapNativeSuper.js

@@ -0,0 +1,35 @@
+import getPrototypeOf from "../getPrototypeOf/getPrototypeOf.js";
+import setPrototypeOf from "../setPrototypeOf/setPrototypeOf.js";
+import isNativeFunction from "../isNativeFunction/isNativeFunction.js";
+import construct from "../construct/construct.js";
+
+var _cache = typeof Map === "function" ? new Map() : undefined;
+
+export default function (Class) {
+  if (Class === null || !isNativeFunction(Class)) return Class;
+
+  if (typeof Class !== "function") {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  if (typeof _cache !== "undefined") {
+    if (_cache.has(Class)) return _cache.get(Class);
+
+    _cache.set(Class, Wrapper);
+  }
+
+  function Wrapper() {
+    // eslint-disable-next-line prefer-rest-params
+    return construct(Class, arguments, getPrototypeOf(this).constructor);
+  }
+
+  Wrapper.prototype = Object.create(Class.prototype, {
+    constructor: {
+      value: Wrapper,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  return setPrototypeOf(Wrapper, Class);
+}

package/dist/babel_helpers/wrapRegExp/wrapRegExp.js

@@ -0,0 +1,67 @@
+import setPrototypeOf from "../setPrototypeOf/setPrototypeOf.js";
+import inherits from "../inherits/inherits.js";
+export default function _wrapRegExp() {
+  _wrapRegExp = function (re, groups) {
+    return new BabelRegExp(re, undefined, groups);
+  };
+
+  var _super = RegExp.prototype;
+
+  var _groups = new WeakMap();
+
+  function BabelRegExp(re, flags, groups) {
+    var _this = new RegExp(re, flags); // if the regex is recreated with 'g' flag
+
+
+    _groups.set(_this, groups || _groups.get(re));
+
+    return setPrototypeOf(_this, BabelRegExp.prototype);
+  }
+
+  inherits(BabelRegExp, RegExp);
+
+  BabelRegExp.prototype.exec = function (str) {
+    var result = _super.exec.call(this, str);
+
+    if (result) result.groups = buildGroups(result, this);
+    return result;
+  };
+
+  BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
+    if (typeof substitution === "string") {
+      var groups = _groups.get(this);
+
+      return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
+        return "$" + groups[name];
+      }));
+    } else if (typeof substitution === "function") {
+      var _this = this;
+
+      return _super[Symbol.replace].call(this, str, function () {
+        var args = arguments; // Modern engines already pass result.groups returned by exec() as the last arg.
+
+        if (typeof args[args.length - 1] !== "object") {
+          args = [].slice.call(args);
+          args.push(buildGroups(args, _this));
+        }
+
+        return substitution.apply(this, args);
+      });
+    } else {
+      return _super[Symbol.replace].call(this, str, substitution);
+    }
+  };
+
+  function buildGroups(result, re) {
+    // NOTE: This function should return undefined if there are no groups,
+    // but in that case Babel doesn't add the wrapper anyway.
+    var g = _groups.get(re);
+
+    return Object.keys(g).reduce(function (groups, name) {
+      groups[name] = result[g[name]];
+      return groups;
+    }, Object.create(null));
+  }
+
+  return _wrapRegExp.apply(this, arguments);
+}

package/dist/babel_helpers/writeOnlyError/writeOnlyError.js

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