@jsenv/plugin-transpilation 1.0.0

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

@@ -0,0 +1,44 @@
+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 TypeError("failed to set property")
+  }
+  return value
+}

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

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

package/src/babel/babel_helper_directory/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/src/babel/babel_helper_directory/babel_helpers/slicedToArray/slicedToArray.js

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

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

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

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

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

package/src/babel/babel_helper_directory/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/src/babel/babel_helper_directory/babel_helpers/temporalRef/temporalRef.js

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

package/src/babel/babel_helper_directory/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/src/babel/babel_helper_directory/babel_helpers/toArray/toArray.js

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,77 @@
+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);
+      var indices = result.indices;
+      if (indices) indices.groups = buildGroups(indices, 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) {
+          var group = groups[name];
+          return "$" + (Array.isArray(group) ? group.join("$") : group);
+        })
+      );
+    } 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) {
+      var i = g[name];
+      if (typeof i === "number") groups[name] = result[i];
+      else {
+        // i is an array of indexes
+        var k = 0;
+        // if no group matched, we stop at k = i.length - 1 and then
+        // we store result[i[i.length - 1]] which is undefined.
+        while (result[i[k]] === undefined && k + 1 < i.length) k++;
+        groups[name] = result[i[k]];
+      }
+      return groups;
+    }, Object.create(null));
+  }
+
+  return _wrapRegExp.apply(this, arguments);
+}

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

package/src/babel/babel_plugin_babel_helpers_as_jsenv_imports.js

@@ -0,0 +1,53 @@
+import { pathToFileURL } from "node:url";
+import { injectJsImport } from "@jsenv/ast";
+
+import {
+  getBabelHelperFileUrl,
+  babelHelperNameFromUrl,
+} from "./babel_helper_directory/babel_helper_directory.js";
+
+// named import approach found here:
+// https://github.com/rollup/rollup-plugin-babel/blob/18e4232a450f320f44c651aa8c495f21c74d59ac/src/helperPlugin.js#L1
+
+// for reference this is how it's done to reference
+// a global babel helper object instead of using
+// a named import
+// https://github.com/babel/babel/blob/99f4f6c3b03c7f3f67cf1b9f1a21b80cfd5b0224/packages/babel-plugin-external-helpers/src/index.js
+
+export const babelPluginBabelHelpersAsJsenvImports = (
+  babel,
+  { getImportSpecifier },
+) => {
+  return {
+    name: "babel-helper-as-jsenv-import",
+    pre: (file) => {
+      const cachedHelpers = {};
+      file.set("helperGenerator", (name) => {
+        // the list of possible helpers name
+        // https://github.com/babel/babel/blob/99f4f6c3b03c7f3f67cf1b9f1a21b80cfd5b0224/packages/babel-helpers/src/helpers.js#L13
+        if (!file.availableHelper(name)) {
+          return undefined;
+        }
+        if (cachedHelpers[name]) {
+          return cachedHelpers[name];
+        }
+        const filePath = file.opts.filename;
+        const fileUrl = pathToFileURL(filePath).href;
+        if (babelHelperNameFromUrl(fileUrl) === name) {
+          return undefined;
+        }
+        const babelHelperImportSpecifier = getBabelHelperFileUrl(name);
+        const helper = injectJsImport({
+          programPath: file.path,
+          from: getImportSpecifier(babelHelperImportSpecifier),
+          nameHint: `_${name}`,
+          // disable interop, useless as we work only with js modules
+          importedType: "es6",
+          // importedInterop: "uncompiled",
+        });
+        cachedHelpers[name] = helper;
+        return helper;
+      });
+    },
+  };
+};

package/src/babel/babel_plugin_structure.js

@@ -0,0 +1,176 @@
+import { createRequire } from "node:module";
+
+import { getBabelHelperFileUrl } from "./babel_helper_directory/babel_helper_directory.js";
+import { babelPluginCompatMap } from "./babel_plugins_compatibility.js";
+
+const requireBabelPlugin = createRequire(import.meta.url);
+
+export const getBaseBabelPluginStructure = ({
+  url,
+  isSupported,
+  // isJsModule,
+  // getImportSpecifier,
+}) => {
+  const isBabelPluginNeeded = (babelPluginName) => {
+    return !isSupported(babelPluginCompatMap[babelPluginName]);
+  };
+
+  const babelPluginStructure = {};
+  if (isBabelPluginNeeded("proposal-numeric-separator")) {
+    babelPluginStructure["proposal-numeric-separator"] = requireBabelPlugin(
+      "@babel/plugin-proposal-numeric-separator",
+    );
+  }
+  if (isBabelPluginNeeded("proposal-json-strings")) {
+    babelPluginStructure["proposal-json-strings"] = requireBabelPlugin(
+      "@babel/plugin-proposal-json-strings",
+    );
+  }
+  if (isBabelPluginNeeded("proposal-object-rest-spread")) {
+    babelPluginStructure["proposal-object-rest-spread"] = requireBabelPlugin(
+      "@babel/plugin-proposal-object-rest-spread",
+    );
+  }
+  if (isBabelPluginNeeded("proposal-optional-catch-binding")) {
+    babelPluginStructure["proposal-optional-catch-binding"] =
+      requireBabelPlugin("@babel/plugin-proposal-optional-catch-binding");
+  }
+  if (isBabelPluginNeeded("proposal-unicode-property-regex")) {
+    babelPluginStructure["proposal-unicode-property-regex"] =
+      requireBabelPlugin("@babel/plugin-proposal-unicode-property-regex");
+  }
+  if (isBabelPluginNeeded("transform-async-to-promises")) {
+    babelPluginStructure["transform-async-to-promises"] = [
+      requireBabelPlugin("babel-plugin-transform-async-to-promises"),
+      {
+        topLevelAwait: "ignore", // will be handled by "jsenv:top_level_await" plugin
+        externalHelpers: false,
+        // enable once https://github.com/rpetrich/babel-plugin-transform-async-to-promises/pull/83
+        // externalHelpers: isJsModule,
+        // externalHelpersPath: isJsModule ? getImportSpecifier(
+        //     "babel-plugin-transform-async-to-promises/helpers.mjs",
+        //   ) : null
+      },
+    ];
+  }
+  if (isBabelPluginNeeded("transform-arrow-functions")) {
+    babelPluginStructure["transform-arrow-functions"] = requireBabelPlugin(
+      "@babel/plugin-transform-arrow-functions",
+    );
+  }
+  if (isBabelPluginNeeded("transform-block-scoped-functions")) {
+    babelPluginStructure["transform-block-scoped-functions"] =
+      requireBabelPlugin("@babel/plugin-transform-block-scoped-functions");
+  }
+  if (isBabelPluginNeeded("transform-block-scoping")) {
+    babelPluginStructure["transform-block-scoping"] = requireBabelPlugin(
+      "@babel/plugin-transform-block-scoping",
+    );
+  }
+  if (isBabelPluginNeeded("transform-classes")) {
+    babelPluginStructure["transform-classes"] = requireBabelPlugin(
+      "@babel/plugin-transform-classes",
+    );
+  }
+  if (isBabelPluginNeeded("transform-computed-properties")) {
+    babelPluginStructure["transform-computed-properties"] = requireBabelPlugin(
+      "@babel/plugin-transform-computed-properties",
+    );
+  }
+  if (isBabelPluginNeeded("transform-destructuring")) {
+    babelPluginStructure["transform-destructuring"] = requireBabelPlugin(
+      "@babel/plugin-transform-destructuring",
+    );
+  }
+  if (isBabelPluginNeeded("transform-dotall-regex")) {
+    babelPluginStructure["transform-dotall-regex"] = requireBabelPlugin(
+      "@babel/plugin-transform-dotall-regex",
+    );
+  }
+  if (isBabelPluginNeeded("transform-duplicate-keys")) {
+    babelPluginStructure["transform-duplicate-keys"] = requireBabelPlugin(
+      "@babel/plugin-transform-duplicate-keys",
+    );
+  }
+  if (isBabelPluginNeeded("transform-exponentiation-operator")) {
+    babelPluginStructure["transform-exponentiation-operator"] =
+      requireBabelPlugin("@babel/plugin-transform-exponentiation-operator");
+  }
+  if (isBabelPluginNeeded("transform-for-of")) {
+    babelPluginStructure["transform-for-of"] = requireBabelPlugin(
+      "@babel/plugin-transform-for-of",
+    );
+  }
+  if (isBabelPluginNeeded("transform-function-name")) {
+    babelPluginStructure["transform-function-name"] = requireBabelPlugin(
+      "@babel/plugin-transform-function-name",
+    );
+  }
+  if (isBabelPluginNeeded("transform-literals")) {
+    babelPluginStructure["transform-literals"] = requireBabelPlugin(
+      "@babel/plugin-transform-literals",
+    );
+  }
+  if (isBabelPluginNeeded("transform-new-target")) {
+    babelPluginStructure["transform-new-target"] = requireBabelPlugin(
+      "@babel/plugin-transform-new-target",
+    );
+  }
+  if (isBabelPluginNeeded("transform-object-super")) {
+    babelPluginStructure["transform-object-super"] = requireBabelPlugin(
+      "@babel/plugin-transform-object-super",
+    );
+  }
+  if (isBabelPluginNeeded("transform-parameters")) {
+    babelPluginStructure["transform-parameters"] = requireBabelPlugin(
+      "@babel/plugin-transform-parameters",
+    );
+  }
+  if (isBabelPluginNeeded("transform-regenerator")) {
+    babelPluginStructure["transform-regenerator"] = [
+      requireBabelPlugin("@babel/plugin-transform-regenerator"),
+      {
+        asyncGenerators: true,
+        generators: true,
+        async: false,
+      },
+    ];
+  }
+  if (isBabelPluginNeeded("transform-shorthand-properties")) {
+    babelPluginStructure["transform-shorthand-properties"] = [
+      requireBabelPlugin("@babel/plugin-transform-shorthand-properties"),
+    ];
+  }
+  if (isBabelPluginNeeded("transform-spread")) {
+    babelPluginStructure["transform-spread"] = [
+      requireBabelPlugin("@babel/plugin-transform-spread"),
+    ];
+  }
+  if (isBabelPluginNeeded("transform-sticky-regex")) {
+    babelPluginStructure["transform-sticky-regex"] = [
+      requireBabelPlugin("@babel/plugin-transform-sticky-regex"),
+    ];
+  }
+  if (isBabelPluginNeeded("transform-template-literals")) {
+    babelPluginStructure["transform-template-literals"] = [
+      requireBabelPlugin("@babel/plugin-transform-template-literals"),
+    ];
+  }
+  if (
+    isBabelPluginNeeded("transform-typeof-symbol") &&
+    // prevent "typeof" to be injected into itself:
+    // - not needed
+    // - would create infinite attempt to transform typeof
+    url !== getBabelHelperFileUrl("typeof")
+  ) {
+    babelPluginStructure["transform-typeof-symbol"] = [
+      requireBabelPlugin("@babel/plugin-transform-typeof-symbol"),
+    ];
+  }
+  if (isBabelPluginNeeded("transform-unicode-regex")) {
+    babelPluginStructure["transform-unicode-regex"] = [
+      requireBabelPlugin("@babel/plugin-transform-unicode-regex"),
+    ];
+  }
+  return babelPluginStructure;
+};