@jsenv/bundling/dist/commonjs/main.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var path = require('path');
var fs = require('fs');
var util = require('util');
var url$1 = require('url');
var https = require('https');

var _defineProperty = (function (obj, key, value) {
  // Shortcircuit the slow defineProperty path when possible.
  // We are trying to avoid issues where setters defined on the
  // prototype cause side effects under the fast path of simple
  // assignment. By checking for existence of the property with
  // the in operator, we can optimize most of this overhead away.
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
});

var nativeTypeOf = function nativeTypeOf(obj) {
  return typeof obj;
};

var customTypeOf = function customTypeOf(obj) {
  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? nativeTypeOf : customTypeOf;

var startsWithWindowsDriveLetter = function startsWithWindowsDriveLetter(string) {
  var firstChar = string[0];
  if (!/[a-zA-Z]/.test(firstChar)) return false;
  var secondChar = string[1];
  if (secondChar !== ":") return false;
  return true;
};

var replaceSlashesWithBackSlashes = function replaceSlashesWithBackSlashes(string) {
  return string.replace(/\//g, "\\");
};

var pathnameToOperatingSystemPath = function pathnameToOperatingSystemPath(pathname) {
  if (pathname[0] !== "/") throw new Error("pathname must start with /, got ".concat(pathname));
  var pathnameWithoutLeadingSlash = pathname.slice(1);

  if (startsWithWindowsDriveLetter(pathnameWithoutLeadingSlash) && pathnameWithoutLeadingSlash[2] === "/") {
    return replaceSlashesWithBackSlashes(pathnameWithoutLeadingSlash);
  } // linux mac pathname === operatingSystemFilename


  return pathname;
};

var isWindowsPath = function isWindowsPath(path) {
  return startsWithWindowsDriveLetter(path) && path[2] === "\\";
};

var replaceBackSlashesWithSlashes = function replaceBackSlashesWithSlashes(string) {
  return string.replace(/\\/g, "/");
};

var operatingSystemPathToPathname = function operatingSystemPathToPathname(operatingSystemPath) {
  if (isWindowsPath(operatingSystemPath)) {
    return "/".concat(replaceBackSlashesWithSlashes(operatingSystemPath));
  } // linux and mac operatingSystemFilename === pathname


  return operatingSystemPath;
};

var pathnameToRelativePathname = function pathnameToRelativePathname(pathname, otherPathname) {
  return pathname.slice(otherPathname.length);
};

// copied from
// https://github.com/babel/babel/blob/0ee2c42b55e1893f0ae6510916405eb273587844/packages/babel-preset-env/data/plugins.json
// Because this is an hidden implementation detail of @babel/preset-env
// it could be deprecated or moved anytime.
// For that reason it makes more sens to have it inlined here
// than importing it from an undocumented location.
// Ideally it would be documented or a separate module
var babelCompatMap = {
  "transform-template-literals": {
    chrome: "41",
    edge: "13",
    firefox: "34",
    node: "4",
    samsung: "3.4",
    opera: "28",
    electron: "0.24"
  },
  "transform-literals": {
    chrome: "44",
    edge: "12",
    firefox: "53",
    safari: "9",
    node: "4",
    ios: "9",
    samsung: "4",
    opera: "31",
    electron: "0.31"
  },
  "transform-function-name": {
    chrome: "51",
    firefox: "53",
    safari: "10",
    node: "6.5",
    ios: "10",
    samsung: "5",
    opera: "38",
    electron: "1.2"
  },
  "transform-arrow-functions": {
    chrome: "47",
    edge: "13",
    firefox: "45",
    safari: "10",
    node: "6",
    ios: "10",
    samsung: "5",
    opera: "34",
    electron: "0.36"
  },
  "transform-block-scoped-functions": {
    chrome: "41",
    edge: "12",
    firefox: "46",
    safari: "10",
    node: "4",
    ie: "11",
    ios: "10",
    samsung: "3.4",
    opera: "28",
    electron: "0.24"
  },
  "transform-classes": {
    chrome: "46",
    edge: "13",
    firefox: "45",
    safari: "10",
    node: "5",
    ios: "10",
    samsung: "5",
    opera: "33",
    electron: "0.36"
  },
  "transform-object-super": {
    chrome: "46",
    edge: "13",
    firefox: "45",
    safari: "10",
    node: "5",
    ios: "10",
    samsung: "5",
    opera: "33",
    electron: "0.36"
  },
  "transform-shorthand-properties": {
    chrome: "43",
    edge: "12",
    firefox: "33",
    safari: "9",
    node: "4",
    ios: "9",
    samsung: "4",
    opera: "30",
    electron: "0.29"
  },
  "transform-duplicate-keys": {
    chrome: "42",
    edge: "12",
    firefox: "34",
    safari: "9",
    node: "4",
    ios: "9",
    samsung: "3.4",
    opera: "29",
    electron: "0.27"
  },
  "transform-computed-properties": {
    chrome: "44",
    edge: "12",
    firefox: "34",
    safari: "7.1",
    node: "4",
    ios: "8",
    samsung: "4",
    opera: "31",
    electron: "0.31"
  },
  "transform-for-of": {
    chrome: "51",
    edge: "15",
    firefox: "53",
    safari: "10",
    node: "6.5",
    ios: "10",
    samsung: "5",
    opera: "38",
    electron: "1.2"
  },
  "transform-sticky-regex": {
    chrome: "49",
    edge: "13",
    firefox: "3",
    safari: "10",
    node: "6",
    ios: "10",
    samsung: "5",
    opera: "36",
    electron: "1"
  },
  "transform-dotall-regex": {
    chrome: "62",
    safari: "11.1",
    node: "8.10",
    ios: "11.3",
    samsung: "8.2",
    opera: "49",
    electron: "3.1"
  },
  "transform-unicode-regex": {
    chrome: "50",
    edge: "13",
    firefox: "46",
    safari: "12",
    node: "6",
    ios: "12",
    samsung: "5",
    opera: "37",
    electron: "1.1"
  },
  "transform-spread": {
    chrome: "46",
    edge: "13",
    firefox: "36",
    safari: "10",
    node: "5",
    ios: "10",
    samsung: "5",
    opera: "33",
    electron: "0.36"
  },
  "transform-parameters": {
    chrome: "49",
    edge: "18",
    firefox: "53",
    safari: "10",
    node: "6",
    ios: "10",
    samsung: "5",
    opera: "36",
    electron: "1"
  },
  "transform-destructuring": {
    chrome: "51",
    edge: "15",
    firefox: "53",
    safari: "10",
    node: "6.5",
    ios: "10",
    samsung: "5",
    opera: "38",
    electron: "1.2"
  },
  "transform-block-scoping": {
    chrome: "49",
    edge: "14",
    firefox: "51",
    safari: "11",
    node: "6",
    ios: "11",
    samsung: "5",
    opera: "36",
    electron: "1"
  },
  "transform-typeof-symbol": {
    chrome: "38",
    edge: "12",
    firefox: "36",
    safari: "9",
    node: "0.12",
    ios: "9",
    samsung: "3",
    opera: "25",
    electron: "0.2"
  },
  "transform-new-target": {
    chrome: "46",
    edge: "14",
    firefox: "41",
    safari: "10",
    node: "5",
    ios: "10",
    samsung: "5",
    opera: "33",
    electron: "0.36"
  },
  "transform-regenerator": {
    chrome: "50",
    edge: "13",
    firefox: "53",
    safari: "10",
    node: "6",
    ios: "10",
    samsung: "5",
    opera: "37",
    electron: "1.1"
  },
  "transform-exponentiation-operator": {
    chrome: "52",
    edge: "14",
    firefox: "52",
    safari: "10.1",
    node: "7",
    ios: "10.3",
    samsung: "6.2",
    opera: "39",
    electron: "1.3"
  },
  "transform-async-to-generator": {
    chrome: "55",
    edge: "15",
    firefox: "52",
    safari: "11",
    node: "7.6",
    ios: "11",
    samsung: "6.2",
    opera: "42",
    electron: "1.6"
  },
  // copy of transform-async-to-generator
  // this is not in the babel-preset-env repo
  // but we need this
  "transform-async-to-promises": {
    chrome: "55",
    edge: "15",
    firefox: "52",
    safari: "11",
    node: "7.6",
    ios: "11",
    samsung: "6.2",
    opera: "42",
    electron: "1.6"
  },
  "proposal-async-generator-functions": {
    chrome: "63",
    firefox: "57",
    safari: "12",
    node: "10",
    ios: "12",
    samsung: "8.2",
    opera: "50",
    electron: "3.1"
  },
  "proposal-object-rest-spread": {
    chrome: "60",
    firefox: "55",
    safari: "11.1",
    node: "8.3",
    ios: "11.3",
    samsung: "8.2",
    opera: "47",
    electron: "2.1"
  },
  "proposal-optional-chaining": {},
  "proposal-unicode-property-regex": {
    chrome: "64",
    safari: "11.1",
    node: "10",
    ios: "11.3",
    opera: "51",
    electron: "3.1"
  },
  "proposal-json-strings": {
    chrome: "66",
    firefox: "62",
    safari: "12",
    node: "10",
    ios: "12",
    opera: "53",
    electron: "3.1"
  },
  "proposal-optional-catch-binding": {
    chrome: "66",
    firefox: "58",
    safari: "11.1",
    node: "10",
    ios: "11.3",
    opera: "53",
    electron: "3.1"
  },
  "transform-named-capturing-groups-regex": {
    chrome: "64",
    safari: "11.1",
    node: "10",
    ios: "11.3",
    opera: "51",
    electron: "3.1"
  },
  "transform-member-expression-literals": {
    chrome: "7",
    opera: "12",
    edge: "12",
    firefox: "2",
    safari: "5.1",
    node: "0.10",
    ie: "9",
    android: "4",
    ios: "6",
    phantom: "2",
    samsung: "2.1",
    electron: "5"
  },
  "transform-property-literals": {
    chrome: "7",
    opera: "12",
    edge: "12",
    firefox: "2",
    safari: "5.1",
    node: "0.10",
    ie: "9",
    android: "4",
    ios: "6",
    phantom: "2",
    samsung: "2.1",
    electron: "5"
  },
  "transform-reserved-words": {
    chrome: "13",
    opera: "10.50",
    edge: "12",
    firefox: "2",
    safari: "3.1",
    node: "0.10",
    ie: "9",
    android: "4.4",
    ios: "6",
    phantom: "2",
    samsung: "2.1",
    electron: "0.2"
  }
};

var hrefToScheme = function hrefToScheme(href) {
  var colonIndex = href.indexOf(":");
  if (colonIndex === -1) return "";
  return href.slice(0, colonIndex);
};

var hrefToOrigin = function hrefToOrigin(href) {
  var scheme = hrefToScheme(href);

  if (scheme === "file") {
    return "file://";
  }

  if (scheme === "http" || scheme === "https") {
    var secondProtocolSlashIndex = scheme.length + "://".length;
    var pathnameSlashIndex = href.indexOf("/", secondProtocolSlashIndex);
    if (pathnameSlashIndex === -1) return href;
    return href.slice(0, pathnameSlashIndex);
  }

  return href.slice(0, scheme.length + 1);
};

var hrefToPathname = function hrefToPathname(href) {
  return ressourceToPathname(hrefToRessource(href));
};

var hrefToRessource = function hrefToRessource(href) {
  var scheme = hrefToScheme(href);

  if (scheme === "file") {
    return href.slice("file://".length);
  }

  if (scheme === "https" || scheme === "http") {
    // remove origin
    var afterProtocol = href.slice(scheme.length + "://".length);
    var pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
    return afterProtocol.slice(pathnameSlashIndex);
  }

  return href.slice(scheme.length + 1);
};

var ressourceToPathname = function ressourceToPathname(ressource) {
  var searchSeparatorIndex = ressource.indexOf("?");
  return searchSeparatorIndex === -1 ? ressource : ressource.slice(0, searchSeparatorIndex);
};

var pathnameIsInside = function pathnameIsInside(pathname, otherPathname) {
  return pathname.startsWith("".concat(otherPathname, "/"));
};

var pathnameToDirname = function pathnameToDirname(pathname) {
  var slashLastIndex = pathname.lastIndexOf("/");
  if (slashLastIndex === -1) return "";
  return pathname.slice(0, slashLastIndex);
};

var pathnameToExtension = function pathnameToExtension(pathname) {
  var slashLastIndex = pathname.lastIndexOf("/");

  if (slashLastIndex !== -1) {
    pathname = pathname.slice(slashLastIndex + 1);
  }

  var dotLastIndex = pathname.lastIndexOf(".");
  if (dotLastIndex === -1) return ""; // if (dotLastIndex === pathname.length - 1) return ""

  return pathname.slice(dotLastIndex);
};

var pathnameToRelativePath = function pathnameToRelativePath(pathname, otherPathname) {
  return pathname.slice(otherPathname.length);
};

var nativeTypeOf$1 = function nativeTypeOf(obj) {
  return typeof obj;
};

var customTypeOf$1 = function customTypeOf(obj) {
  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};

var _typeof$1 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? nativeTypeOf$1 : customTypeOf$1;

var _defineProperty$1 = (function (obj, key, value) {
  // Shortcircuit the slow defineProperty path when possible.
  // We are trying to avoid issues where setters defined on the
  // prototype cause side effects under the fast path of simple
  // assignment. By checking for existence of the property with
  // the in operator, we can optimize most of this overhead away.
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
});

function _objectSpread (target) {
  for (var i = 1; i < arguments.length; i++) {
    // eslint-disable-next-line prefer-rest-params
    var source = arguments[i] === null ? {} : arguments[i];

    if (i % 2) {
      // eslint-disable-next-line no-loop-func
      ownKeys(source, true).forEach(function (key) {
        _defineProperty$1(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      // eslint-disable-next-line no-loop-func
      ownKeys(source).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
} // 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;
    }); // eslint-disable-next-line prefer-spread

    keys.push.apply(keys, symbols);
  }

  return keys;
}

// eslint-disable-next-line import/no-unresolved
var nodeRequire = require;
var filenameContainsBackSlashes = __filename.indexOf("\\") > -1;
var url = filenameContainsBackSlashes ? "file://".concat(__filename.replace(/\\/g, "/")) : "file://".concat(__filename);

var jsenvCorePath;

if (typeof __filename === "string") {
  jsenvCorePath = path.resolve(__filename, "../../../"); // get ride of dist/commonjs/main.js
} else {
  var selfPathname = hrefToPathname(url);
  var selfPath = pathnameToOperatingSystemPath(selfPathname);
  jsenvCorePath = path.resolve(selfPath, "../../../"); // get ride of src/jsenvCorePath/jsenvCorePath.js
}
var jsenvCorePathname = operatingSystemPathToPathname(jsenvCorePath);

var _require2 = nodeRequire("@babel/helpers"),
    list = _require2.list;
list.forEach(function (babelHelperName) {
});

// https://www.statista.com/statistics/268299/most-popular-internet-browsers/
// this source of stat is what I found in 5min
// we could improve these default usage score using better stats
// and keep in mind this should be updated time to time or even better
// come from a project specific audience
var browserScoreMap = {
  android: 0.001,
  chrome: {
    "71": 0.3,
    "69": 0.19,
    "0": 0.01 // it means oldest version of chrome will get a score of 0.01

  },
  firefox: {
    "61": 0.3
  },
  edge: {
    "12": 0.1
  },
  electron: 0.001,
  ios: 0.001,
  opera: 0.001,
  other: 0.001,
  safari: {
    "10": 0.1
  }
};

// certainly needs to be moved to @dmail/cancellation
var firstOperationMatching = function firstOperationMatching(_ref) {
  var array = _ref.array,
      start = _ref.start,
      predicate = _ref.predicate;
  if (_typeof(array) !== "object") throw new TypeError(createArrayErrorMessage({
    array: array
  }));
  if (typeof start !== "function") throw new TypeError(createStartErrorMessage({
    start: start
  }));
  if (typeof predicate !== "function") throw new TypeError(createPredicateErrorMessage({
    predicate: predicate
  }));
  return new Promise(function (resolve, reject) {
    var visit = function visit(index) {
      if (index >= array.length) {
        return resolve();
      }

      var input = array[index];
      var returnValue = start(input);
      return Promise.resolve(returnValue).then(function (output) {
        if (predicate(output)) {
          return resolve(output);
        }

        return visit(index + 1);
      }, reject);
    };

    visit(0);
  });
};

var createArrayErrorMessage = function createArrayErrorMessage(_ref2) {
  var array = _ref2.array;
  return "array must be an object.\narray: ".concat(array);
};

var createStartErrorMessage = function createStartErrorMessage(_ref3) {
  var start = _ref3.start;
  return "start must be a function.\nstart: ".concat(start);
};

var createPredicateErrorMessage = function createPredicateErrorMessage(_ref4) {
  var predicate = _ref4.predicate;
  return "predicate must be a function.\npredicate: ".concat(predicate);
};

function _objectSpread$1 (target) {
  for (var i = 1; i < arguments.length; i++) {
    // eslint-disable-next-line prefer-rest-params
    var source = arguments[i] === null ? {} : arguments[i];

    if (i % 2) {
      // eslint-disable-next-line no-loop-func
      ownKeys$1(source, true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      // eslint-disable-next-line no-loop-func
      ownKeys$1(source).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
} // 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$1(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;
    }); // eslint-disable-next-line prefer-spread

    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _await(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _empty() {}

function _awaitIgnored(value, direct) {
  if (!direct) {
    return value && value.then ? value.then(_empty) : Promise.resolve();
  }
}

function _call(body, then, direct) {
  if (direct) {
    return then ? then(body()) : body();
  }

  try {
    var result = Promise.resolve(body());
    return then ? result.then(then) : result;
  } catch (e) {
    return Promise.reject(e);
  }
}

function _async(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var promiseSequence = function promiseSequence(callbackArray) {
  var values = [];

  var visit = _async(function (index) {
    if (index === callbackArray.length) return;
    var callback = callbackArray[index];
    return _call(callback, function (value) {
      values.push(value);
      return _awaitIgnored(visit(index + 1));
    });
  });

  return _await(visit(0), function () {
    return values;
  });
};

// export const ensureFolderLeadingTo = (file) => {
//   return new Promise((resolve, reject) => {
//     fs.mkdir(path.dirname(file), { resurcive: true }, (error) => {
//       if (error) {
//         if (error.code === "EEXIST") {
//           resolve()
//           return
//         }
//         reject(error)
//         return
//       }
//       resolve()
//     })
//   })
// }

function _await$1(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _empty$1() {}

function _invokeIgnored(body) {
  var result = body();

  if (result && result.then) {
    return result.then(_empty$1);
  }
}

function _async$1(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var fileMakeDirname = function fileMakeDirname(file) {
  var fileNormalized = normalizeSeparation(file); // remove first / in case path starts with / (linux)
  // because it would create a "" entry in folders array below
  // tryig to create a folder at ""

  var fileStartsWithSlash = fileNormalized[0] === "/";
  var pathname = fileStartsWithSlash ? fileNormalized.slice(1) : fileNormalized;
  var folders = pathname.split("/");
  folders.pop();
  return promiseSequence(folders.map(function (_, index) {
    return function () {
      var folder = folders.slice(0, index + 1).join("/");
      return folderMake("".concat(fileStartsWithSlash ? "/" : "").concat(folder));
    };
  }));
};

var normalizeSeparation = function normalizeSeparation(file) {
  return file.replace(/\\/g, "/");
};

var folderMake = function folderMake(folder) {
  return new Promise(function (resolve, reject) {
    fs.mkdir(folder, _async$1(function (error) {
      return _invokeIgnored(function () {
        if (error) {
          // au cas ou deux script essayent de crée un dossier peu importe qui y arrive c'est ok
          return _invokeIgnored(function () {
            if (error.code === "EEXIST") {
              return _await$1(fileLastStat(folder), function (stat) {
                if (stat.isDirectory()) {
                  resolve();
                } else {
                  reject({
                    status: 500,
                    reason: "expect a directory"
                  });
                }
              });
            } else {
              reject({
                status: 500,
                reason: error.code
              });
            }
          });
        } else {
          resolve();
        }
      });
    }));
  });
};

var fileLastStat = function fileLastStat(path) {
  return new Promise(function (resolve, reject) {
    fs.lstat(path, function (error, lstat) {
      if (error) {
        reject({
          status: 500,
          reason: error.code
        });
      } else {
        resolve(lstat);
      }
    });
  });
};

var copyFilePromisified = util.promisify(fs.copyFile);

function _await$2(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var readFilePromisified = util.promisify(fs.readFile);

function _async$2(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var fileRead = _async$2(function (file) {
  return _await$2(readFilePromisified(file), function (buffer) {
    return buffer.toString();
  });
});

var statPromisified = util.promisify(fs.stat);

var lstatPromisified = util.promisify(fs.lstat);

function _await$3(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var writeFilePromisified = util.promisify(fs.writeFile);

function _async$3(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var fileWrite = _async$3(function (file, content) {
  return _await$3(fileMakeDirname(file), function () {
    return writeFilePromisified(file, content);
  });
});

var readdirPromisified = util.promisify(fs.readdir);

var rimraf = nodeRequire("rimraf");

var BEST_ID = "best";
var OTHERWISE_ID = "otherwise";

var _require2$1 = nodeRequire("@babel/core"),
    buildExternalHelpers = _require2$1.buildExternalHelpers;

var _require3 = nodeRequire("@babel/helpers"),
    getDependencies = _require3.getDependencies;

// we could reuse this to get a list of polyfill
// using https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/built-ins.json#L1
// adding a featureNameArray to every group
// and according to that featureNameArray, add these polyfill
// to the generated bundle
var polyfillCompatMap = {};

// eslint-disable-next-line consistent-return
var arrayWithoutHoles = (function (arr) {
  if (Array.isArray(arr)) {
    var i = 0;
    var arr2 = new Array(arr.length);

    for (; i < arr.length; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }
});

// eslint-disable-next-line consistent-return
var iterableToArray = (function (iter) {
  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
});

var nonIterableSpread = (function () {
  throw new TypeError("Invalid attempt to spread non-iterable instance");
});

var _toConsumableArray = (function (arr) {
  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
});

var valueToVersion = function valueToVersion(value) {
  if (typeof value === "number") {
    return numberToVersion(value);
  }

  if (typeof value === "string") {
    return stringToVersion(value);
  }

  throw new TypeError(createValueErrorMessage({
    version: value
  }));
};

var numberToVersion = function numberToVersion(number) {
  return {
    major: number,
    minor: 0,
    patch: 0
  };
};

var stringToVersion = function stringToVersion(string) {
  if (string.indexOf(".") > -1) {
    var parts = string.split(".");
    return {
      major: Number(parts[0]),
      minor: parts[1] ? Number(parts[1]) : 0,
      patch: parts[2] ? Number(parts[2]) : 0
    };
  }

  if (isNaN(string)) {
    return {
      major: 0,
      minor: 0,
      patch: 0
    };
  }

  return {
    major: Number(string),
    minor: 0,
    patch: 0
  };
};

var createValueErrorMessage = function createValueErrorMessage(_ref) {
  var value = _ref.value;
  return "value must be a number or a string.\nvalue: ".concat(value);
};

var versionCompare = function versionCompare(versionA, versionB) {
  var semanticVersionA = valueToVersion(versionA);
  var semanticVersionB = valueToVersion(versionB);
  var majorDiff = semanticVersionA.major - semanticVersionB.major;

  if (majorDiff > 0) {
    return majorDiff;
  }

  if (majorDiff < 0) {
    return majorDiff;
  }

  var minorDiff = semanticVersionA.minor - semanticVersionB.minor;

  if (minorDiff > 0) {
    return minorDiff;
  }

  if (minorDiff < 0) {
    return minorDiff;
  }

  var patchDiff = semanticVersionA.patch - semanticVersionB.patch;

  if (patchDiff > 0) {
    return patchDiff;
  }

  if (patchDiff < 0) {
    return patchDiff;
  }

  return 0;
};

var versionIsBelow = function versionIsBelow(versionSupposedBelow, versionSupposedAbove) {
  return versionCompare(versionSupposedBelow, versionSupposedAbove) < 0;
};

var findHighestVersion = function findHighestVersion() {
  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
    values[_key] = arguments[_key];
  }

  if (values.length === 0) throw new Error("missing argument");
  return values.reduce(function (highestVersion, value) {
    if (versionIsBelow(highestVersion, value)) {
      return value;
    }

    return highestVersion;
  });
};

var computeIncompatibleNameArray = function computeIncompatibleNameArray(_ref) {
  var featureCompatMap = _ref.featureCompatMap,
      platformName = _ref.platformName,
      platformVersion = _ref.platformVersion;
  var incompatibleNameArray = [];
  Object.keys(featureCompatMap).forEach(function (featureName) {
    var compatible = platformIsCompatibleWithFeature({
      platformName: platformName,
      platformVersion: platformVersion,
      featureCompat: featureName in featureCompatMap ? featureCompatMap[featureName] : {}
    });

    if (!compatible) {
      incompatibleNameArray.push(featureName);
    }
  });
  return incompatibleNameArray;
};

var platformIsCompatibleWithFeature = function platformIsCompatibleWithFeature(_ref2) {
  var platformName = _ref2.platformName,
      platformVersion = _ref2.platformVersion,
      featureCompat = _ref2.featureCompat;
  var platformCompatibleVersion = computePlatformCompatibleVersion({
    featureCompat: featureCompat,
    platformName: platformName
  });
  var highestVersion = findHighestVersion(platformVersion, platformCompatibleVersion);
  return highestVersion === platformVersion;
};

var computePlatformCompatibleVersion = function computePlatformCompatibleVersion(_ref3) {
  var featureCompat = _ref3.featureCompat,
      platformName = _ref3.platformName;
  return platformName in featureCompat ? featureCompat[platformName] : "Infinity";
};

var generatePlatformGroupArray = function generatePlatformGroupArray(_ref) {
  var featureCompatMap = _ref.featureCompatMap,
      platformName = _ref.platformName;
  var featureNameArray = Object.keys(featureCompatMap);
  var featureNameArrayWithCompat = featureNameArray.filter(function (featureName) {
    return platformName in featureCompatMap[featureName];
  });
  var versionArray = featureNameArrayWithCompat // why do I convert them to string, well ok let's keep it like that
  .map(function (featureName) {
    return String(featureCompatMap[featureName][platformName]);
  }).concat("0.0.0") // at least version 0
  // filter is to have unique version I guess
  .filter(function (version, index, array) {
    return array.indexOf(version) === index;
  }).sort(versionCompare);
  var platformGroupArray = [];
  versionArray.forEach(function (version) {
    var incompatibleNameArray = computeIncompatibleNameArray({
      featureCompatMap: featureCompatMap,
      platformName: platformName,
      platformVersion: version
    }).sort();
    var groupWithSameIncompatibleFeatures = platformGroupArray.find(function (platformGroup) {
      return platformGroup.incompatibleNameArray.join("") === incompatibleNameArray.join("");
    });

    if (groupWithSameIncompatibleFeatures) {
      groupWithSameIncompatibleFeatures.platformCompatMap[platformName] = findHighestVersion(groupWithSameIncompatibleFeatures.platformCompatMap[platformName], version);
    } else {
      platformGroupArray.push({
        incompatibleNameArray: incompatibleNameArray.slice(),
        platformCompatMap: _defineProperty$1({}, platformName, version)
      });
    }
  });
  return platformGroupArray;
};

var composePlatformCompatMap = function composePlatformCompatMap(platformCompatMap, secondPlatformCompatMap) {
  return objectComposeValue(normalizePlatformCompatMapVersions(platformCompatMap), normalizePlatformCompatMapVersions(secondPlatformCompatMap), function (version, secondVersion) {
    return findHighestVersion(version, secondVersion);
  });
};

var normalizePlatformCompatMapVersions = function normalizePlatformCompatMapVersions(platformCompatibility) {
  return objectMapValue(platformCompatibility, function (version) {
    return String(version);
  });
};

var objectMapValue = function objectMapValue(object, callback) {
  var mapped = {};
  Object.keys(object).forEach(function (key) {
    mapped[key] = callback(object[key], key, object);
  });
  return mapped;
};

var objectComposeValue = function objectComposeValue(previous, object, callback) {
  var composed = _objectSpread({}, previous);

  Object.keys(object).forEach(function (key) {
    composed[key] = key in composed ? callback(composed[key], object[key]) : object[key];
  });
  return composed;
};

var composeGroupArray = function composeGroupArray() {
  for (var _len = arguments.length, arrayOfGroupArray = new Array(_len), _key = 0; _key < _len; _key++) {
    arrayOfGroupArray[_key] = arguments[_key];
  }

  return arrayOfGroupArray.reduce(groupArrayReducer, []);
};

var groupArrayReducer = function groupArrayReducer(previousGroupArray, groupArray) {
  var reducedGroupArray = [];
  previousGroupArray.forEach(function (group) {
    reducedGroupArray.push({
      incompatibleNameArray: group.incompatibleNameArray.slice(),
      platformCompatMap: _objectSpread({}, group.platformCompatMap)
    });
  });
  groupArray.forEach(function (group) {
    var groupWithSameIncompatibleFeature = reducedGroupArray.find(function (existingGroupCandidate) {
      return groupHaveSameIncompatibleFeatures(group, existingGroupCandidate);
    });

    if (groupWithSameIncompatibleFeature) {
      groupWithSameIncompatibleFeature.platformCompatMap = composePlatformCompatMap(groupWithSameIncompatibleFeature.platformCompatMap, group.platformCompatMap);
    } else {
      reducedGroupArray.push({
        incompatibleNameArray: group.incompatibleNameArray.slice(),
        platformCompatMap: _objectSpread({}, group.platformCompatMap)
      });
    }
  });
  return reducedGroupArray;
};

var groupHaveSameIncompatibleFeatures = function groupHaveSameIncompatibleFeatures(groupA, groupB) {
  return groupA.incompatibleNameArray.join("") === groupB.incompatibleNameArray.join("");
};

var generateAllPlatformGroupArray = function generateAllPlatformGroupArray(_ref) {
  var featureCompatMap = _ref.featureCompatMap,
      platformNames = _ref.platformNames;
  var arrayOfGroupArray = platformNames.map(function (platformName) {
    return generatePlatformGroupArray({
      featureCompatMap: featureCompatMap,
      platformName: platformName
    });
  });
  var groupArray = composeGroupArray.apply(void 0, _toConsumableArray(arrayOfGroupArray));
  return groupArray;
};

var platformCompatMapToScore = function platformCompatMapToScore(platformCompatMap, platformScoreMap) {
  return Object.keys(platformCompatMap).reduce(function (previous, platformName) {
    var platformVersion = platformCompatMap[platformName];
    return previous + platformToScore(platformName, platformVersion, platformScoreMap);
  }, 0);
};

var platformToScore = function platformToScore(platformName, platformVersion, platformScoreMap) {
  if (platformName in platformScoreMap === false) return platformScoreMap.other || 0;
  var versionUsageMap = platformScoreMap[platformName];
  var versionArray = Object.keys(versionUsageMap);
  if (versionArray.length === 0) return platformScoreMap.other || 0;
  var versionArrayAscending = versionArray.sort(versionCompare);
  var highestVersion = versionArrayAscending[versionArray.length - 1];
  if (findHighestVersion(platformVersion, highestVersion) === platformVersion) return versionUsageMap[highestVersion];
  var closestVersion = versionArrayAscending.reverse().find(function (version) {
    return findHighestVersion(platformVersion, version) === platformVersion;
  });
  if (!closestVersion) return platformScoreMap.other || 0;
  return versionUsageMap[closestVersion];
};

var generateGroupMap = function generateGroupMap(_ref) {
  var babelPluginMap = _ref.babelPluginMap,
      _ref$babelCompatMap = _ref.babelCompatMap,
      babelCompatMap$1 = _ref$babelCompatMap === void 0 ? babelCompatMap : _ref$babelCompatMap,
      _ref$polyfillConfigMa = _ref.polyfillConfigMap,
      polyfillConfigMap = _ref$polyfillConfigMa === void 0 ? {} : _ref$polyfillConfigMa,
      _ref$polyfillCompatMa = _ref.polyfillCompatMap,
      polyfillCompatMap$1 = _ref$polyfillCompatMa === void 0 ? polyfillCompatMap : _ref$polyfillCompatMa,
      platformScoreMap = _ref.platformScoreMap,
      _ref$groupCount = _ref.groupCount,
      groupCount = _ref$groupCount === void 0 ? 1 : _ref$groupCount,
      _ref$platformAlwaysIn = _ref.platformAlwaysInsidePlatformScoreMap,
      platformAlwaysInsidePlatformScoreMap = _ref$platformAlwaysIn === void 0 ? false : _ref$platformAlwaysIn,
      _ref$platformWillAlwa = _ref.platformWillAlwaysBeKnown,
      platformWillAlwaysBeKnown = _ref$platformWillAlwa === void 0 ? false : _ref$platformWillAlwa;
  var groupMap = generateFeatureGroupMap({
    // here we should throw if key conflict between babelPluginMap/polyfillConfigMap
    featureConfigMap: _objectSpread({}, babelPluginMap, {}, polyfillConfigMap),
    // here we should throw if key conflict on babelCompatMap/polyfillCompatMap
    featureCompatMap: _objectSpread({}, babelCompatMap$1, {}, polyfillCompatMap$1),
    platformScoreMap: platformScoreMap,
    groupCount: groupCount,
    platformAlwaysInsidePlatformScoreMap: platformAlwaysInsidePlatformScoreMap,
    platformWillAlwaysBeKnown: platformWillAlwaysBeKnown
  });
  return groupMap;
};

var generateFeatureGroupMap = function generateFeatureGroupMap(_ref2) {
  var featureConfigMap = _ref2.featureConfigMap,
      featureCompatMap = _ref2.featureCompatMap,
      platformScoreMap = _ref2.platformScoreMap,
      groupCount = _ref2.groupCount,
      platformAlwaysInsidePlatformScoreMap = _ref2.platformAlwaysInsidePlatformScoreMap,
      platformWillAlwaysBeKnown = _ref2.platformWillAlwaysBeKnown;
  if (_typeof$1(featureConfigMap) !== "object") throw new TypeError("featureConfigMap must be an object, got ".concat(featureConfigMap));
  if (_typeof$1(featureCompatMap) !== "object") throw new TypeError("featureCompatMap must be an object, got ".concat(featureCompatMap));
  if (_typeof$1(platformScoreMap) !== "object") throw new TypeError("platformScoreMap must be an object, got ".concat(platformScoreMap));
  if (_typeof$1(groupCount) < 1) throw new TypeError("groupCount must be above 1, got ".concat(groupCount));
  var featureNameArray = Object.keys(featureConfigMap);
  var groupWithoutFeature = {
    incompatibleNameArray: featureNameArray,
    platformCompatMap: {}
  }; // when we create one group and we cannot ensure
  // code will be runned on a platform inside platformScoreMap
  // then we return otherwise group to be safe

  if (groupCount === 1 && !platformAlwaysInsidePlatformScoreMap) {
    return _defineProperty$1({}, OTHERWISE_ID, groupWithoutFeature);
  }

  var featureCompatMapWithoutHole = {};
  featureNameArray.forEach(function (featureName) {
    featureCompatMapWithoutHole[featureName] = featureName in featureCompatMap ? featureCompatMap[featureName] : {};
  });
  var allPlatformGroupArray = generateAllPlatformGroupArray({
    featureCompatMap: featureCompatMapWithoutHole,
    platformNames: arrayWithoutValue(Object.keys(platformScoreMap), "other")
  });

  if (allPlatformGroupArray.length === 0) {
    return _defineProperty$1({}, OTHERWISE_ID, groupWithoutFeature);
  }

  var groupToScore = function groupToScore(_ref5) {
    var platformCompatMap = _ref5.platformCompatMap;
    return platformCompatMapToScore(platformCompatMap, platformScoreMap);
  };

  var allPlatformGroupArraySortedByScore = allPlatformGroupArray.sort(function (a, b) {
    return groupToScore(b) - groupToScore(a);
  });
  var length = allPlatformGroupArraySortedByScore.length; // if we arrive here and want a single group
  // we take the worst group and consider it's our best group
  // because it's the lowest platform we want to support

  if (groupCount === 1) {
    return _defineProperty$1({}, BEST_ID, allPlatformGroupArraySortedByScore[length - 1]);
  }

  var addOtherwiseToBeSafe = !platformAlwaysInsidePlatformScoreMap || !platformWillAlwaysBeKnown;
  var lastGroupIndex = addOtherwiseToBeSafe ? groupCount - 1 : groupCount;
  var groupArray = length + 1 > groupCount ? allPlatformGroupArraySortedByScore.slice(0, lastGroupIndex) : allPlatformGroupArraySortedByScore;
  var groupMap = {};
  groupArray.forEach(function (group, index) {
    if (index === 0) {
      groupMap[BEST_ID] = group;
    } else {
      groupMap["intermediate-".concat(index + 1)] = group;
    }
  });

  if (addOtherwiseToBeSafe) {
    groupMap[OTHERWISE_ID] = groupWithoutFeature;
  }

  return groupMap;
};

var arrayWithoutValue = function arrayWithoutValue(array, value) {
  return array.filter(function (valueCandidate) {
    return valueCandidate !== value;
  });
};

var LOG_LEVEL_OFF = "off";
var LOG_LEVEL_ERROR = "error";
var LOG_LEVEL_WARN = "warn";
var LOG_LEVEL_INFO = "info";
var LOG_LEVEL_TRACE = "trace";

var createLogger = function createLogger() {
  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      _ref$logLevel = _ref.logLevel,
      logLevel = _ref$logLevel === void 0 ? LOG_LEVEL_INFO : _ref$logLevel;

  if (logLevel === LOG_LEVEL_TRACE) {
    return {
      trace: trace,
      info: info,
      warn: warn,
      error: error
    };
  }

  if (logLevel === LOG_LEVEL_INFO) {
    return {
      trace: traceDisabled,
      info: info,
      warn: warn,
      error: error
    };
  }

  if (logLevel === LOG_LEVEL_WARN) {
    return {
      trace: traceDisabled,
      info: infoDisabled,
      warn: warn,
      error: error
    };
  }

  if (logLevel === LOG_LEVEL_ERROR) {
    return {
      trace: traceDisabled,
      info: infoDisabled,
      warn: warnDisabled,
      error: error
    };
  }

  if (logLevel === LOG_LEVEL_OFF) {
    return {
      trace: traceDisabled,
      info: infoDisabled,
      warn: warnDisabled,
      error: errorDisabled
    };
  }

  throw new Error(createUnexpectedLogLevelMessage({
    logLevel: logLevel
  }));
};

var createUnexpectedLogLevelMessage = function createUnexpectedLogLevelMessage(_ref2) {
  var logLevel = _ref2.logLevel;
  return "unexpected logLevel.\n--- logLevel ---\n".concat(logLevel, "\n--- allowed log levels ---\n").concat(LOG_LEVEL_OFF, "\n").concat(LOG_LEVEL_ERROR, "\n").concat(LOG_LEVEL_WARN, "\n").concat(LOG_LEVEL_INFO, "\n").concat(LOG_LEVEL_TRACE, "\n");
};

var trace = console.trace;

var traceDisabled = function traceDisabled() {};

var info = console.log;

var infoDisabled = function infoDisabled() {};

var warn = console.warn;

var warnDisabled = function warnDisabled() {};

var error = console.error;

var errorDisabled = function errorDisabled() {};

var _require2$2 = nodeRequire("@dmail/server"),
    bufferToEtag = _require2$2.bufferToEtag;

var _require2$3 = nodeRequire("@dmail/server"),
    bufferToEtag$1 = _require2$3.bufferToEtag;

var lockfile = nodeRequire("proper-lockfile");

// https://nodejs.org/metrics/summaries/version/nodejs.org-access.log.csv
var nodeVersionScoreMap = {
  "0.10": 0.02,
  "0.12": 0.01,
  4: 0.1,
  6: 0.25,
  7: 0.1,
  8: 1,
  9: 0.1,
  10: 0.5,
  11: 0.25
};

var assertImportMap = function assertImportMap(value) {
  if (value === null) {
    throw new TypeError("an importMap must be an object, got null");
  }

  var type = _typeof$1(value);

  if (type !== "object") {
    throw new TypeError("an importMap must be an object, received ".concat(value));
  }

  if (Array.isArray(value)) {
    throw new TypeError("an importMap must be an object, received array ".concat(value));
  }
};

// https://url.spec.whatwg.org/#example-start-with-a-widows-drive-letter
var isWindowsDriveLetter = function isWindowsDriveLetter(specifier) {
  var firstChar = specifier[0];
  if (!/[a-zA-Z]/.test(firstChar)) return false;
  var secondChar = specifier[1];
  if (secondChar !== ":") return false;
  var thirdChar = specifier[2];
  return thirdChar === "/";
};

// "file:///folder/file.js"
// "chrome://folder/file.js"

var isAbsoluteSpecifier = function isAbsoluteSpecifier(specifier) {
  // window drive letter could are not protocol yep
  // something like `C:/folder/file.js`
  // will be considered as a bare import
  if (isWindowsDriveLetter(specifier.slice(0, 3))) return false;
  return /^[a-zA-Z]+:/.test(specifier);
};
var resolveAbsoluteSpecifier = function resolveAbsoluteSpecifier(specifier) {
  return specifier;
};

var assertUrlLike = function assertUrlLike(value) {
  var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "specifier";

  if (typeof value !== "string") {
    throw new TypeError("".concat(name, " must be a string, got ").concat(value));
  }

  if (!isAbsoluteSpecifier(value)) {
    throw new Error("".concat(name, " must be an url and no scheme found, got ").concat(value));
  }
};

var applyImportMap = function applyImportMap(_ref) {
  var importMap = _ref.importMap,
      href = _ref.href,
      importerHref = _ref.importerHref;
  assertImportMap(importMap);
  assertUrlLike(href, "href");

  if (importerHref) {
    assertUrlLike(importerHref, "importerHref");
  }

  var scopes = importMap.scopes;

  if (scopes && importerHref) {
    var scopeKeyMatching = Object.keys(scopes).find(function (scopeKey) {
      return scopeKey === importerHref || specifierIsPrefixOf(scopeKey, importerHref);
    });

    if (scopeKeyMatching) {
      var scopeValue = scopes[scopeKeyMatching];
      var remappingFromScopeImports = applyImports(href, scopeValue);

      if (remappingFromScopeImports !== null) {
        return remappingFromScopeImports;
      }
    }
  }

  var imports = importMap.imports;

  if (imports) {
    var remappingFromImports = applyImports(href, imports);

    if (remappingFromImports !== null) {
      return remappingFromImports;
    }
  }

  return href;
};

var applyImports = function applyImports(href, imports) {
  var importKeyArray = Object.keys(imports);
  var i = 0;

  while (i < importKeyArray.length) {
    var importKey = importKeyArray[i];
    i++;

    if (importKey === href) {
      var importValue = imports[importKey];
      return importValue;
    }

    if (specifierIsPrefixOf(importKey, href)) {
      var _importValue = imports[importKey];
      var afterImportKey = href.slice(importKey.length);
      return _importValue + afterImportKey;
    }
  }

  return null;
};

var specifierIsPrefixOf = function specifierIsPrefixOf(specifierHref, href) {
  return specifierHref[specifierHref.length - 1] === "/" && href.startsWith(specifierHref);
};

var composeTwoImportMaps = function composeTwoImportMaps(leftImportMap, rightImportMap) {
  assertImportMap(leftImportMap);
  assertImportMap(rightImportMap);
  return {
    imports: composeTwoImports(leftImportMap.imports, rightImportMap.imports),
    scopes: composeTwoScopes(leftImportMap.scopes, rightImportMap.scopes)
  };
};

var composeTwoImports = function composeTwoImports() {
  var leftImports = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var rightImports = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  return _objectSpread({}, leftImports, {}, rightImports);
};

var composeTwoScopes = function composeTwoScopes() {
  var leftScopes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var rightScopes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  var scopes = _objectSpread({}, leftScopes);

  Object.keys(rightScopes).forEach(function (scopeKey) {
    if (scopes.hasOwnProperty(scopeKey)) {
      scopes[scopeKey] = _objectSpread({}, scopes[scopeKey], {}, rightScopes[scopeKey]);
    } else {
      scopes[scopeKey] = _objectSpread({}, rightScopes[scopeKey]);
    }
  });
  return scopes;
};

var isSchemeRelativeSpecifier = function isSchemeRelativeSpecifier(specifier) {
  return specifier.slice(0, 2) === "//";
};
var resolveSchemeRelativeSpecifier = function resolveSchemeRelativeSpecifier(specifier, importer) {
  return "".concat(hrefToScheme(importer), ":").concat(specifier);
};

var isOriginRelativeSpecifier = function isOriginRelativeSpecifier(specifier) {
  var firstChar = specifier[0];
  if (firstChar !== "/") return false;
  var secondChar = specifier[1];
  if (secondChar === "/") return false;
  return true;
};
var resolveOriginRelativeSpecifier = function resolveOriginRelativeSpecifier(specifier, importer) {
  var importerOrigin = hrefToOrigin(importer);
  return "".concat(importerOrigin, "/").concat(specifier.slice(1));
};

// https://github.com/systemjs/systemjs/blob/master/src/common.js
// "../folder/file.js"

var isPathnameRelativeSpecifier = function isPathnameRelativeSpecifier(specifier) {
  if (specifier.slice(0, 2) === "./") return true;
  if (specifier.slice(0, 3) === "../") return true;
  return false;
};
var resolvePathnameRelativeSpecifier = function resolvePathnameRelativeSpecifier(specifier, importer) {
  var importerPathname = hrefToPathname(importer); // ./foo.js on /folder/file.js -> /folder/foo.js
  // ./foo/bar.js on /folder/file.js -> /folder/foo/bar.js
  // ./foo.js on /folder/subfolder/file.js -> /folder/subfolder/foo.js

  if (specifier.slice(0, 2) === "./") {
    var _importerOrigin = hrefToOrigin(importer);

    var importerDirname = pathnameToDirname(importerPathname);
    return "".concat(_importerOrigin).concat(importerDirname, "/").concat(specifier.slice(2));
  } // ../foo/bar.js on /folder/file.js -> /foo/bar.js
  // ../foo/bar.js on /folder/subfolder/file.js -> /folder/foo/bar.js
  // ../../foo/bar.js on /folder/file.js -> /foo/bar.js
  // ../bar.js on / -> /bar.js


  var unresolvedPathname = specifier;
  var importerFolders = importerPathname.split("/");
  importerFolders.pop(); // remove file, it is not a folder

  while (unresolvedPathname.slice(0, 3) === "../") {
    // when there is no folder left to resolved
    // we just ignore '../'
    if (importerFolders.length) {
      importerFolders.pop();
    }

    unresolvedPathname = unresolvedPathname.slice(3);
  }

  var importerOrigin = hrefToOrigin(importer);
  var resolvedPathname = "".concat(importerFolders.join("/"), "/").concat(unresolvedPathname);
  return "".concat(importerOrigin).concat(resolvedPathname);
};

var resolveBareSpecifier = function resolveBareSpecifier(specifier, importer) {
  var importerOrigin = hrefToOrigin(importer);
  return "".concat(importerOrigin, "/").concat(specifier);
};

// could be useful: https://url.spec.whatwg.org/#url-miscellaneous
var resolveSpecifier = function resolveSpecifier(specifier, importer) {
  if (isAbsoluteSpecifier(specifier)) {
    return resolveAbsoluteSpecifier(specifier);
  }

  if (!importer) {
    throw new Error(createMissingImporterMessage(specifier, importer));
  }

  if (isSchemeRelativeSpecifier(specifier)) {
    return resolveSchemeRelativeSpecifier(specifier, importer);
  }

  if (isOriginRelativeSpecifier(specifier)) {
    return resolveOriginRelativeSpecifier(specifier, importer);
  }

  if (isPathnameRelativeSpecifier(specifier)) {
    return resolvePathnameRelativeSpecifier(specifier, importer);
  }

  return resolveBareSpecifier(specifier, importer);
};

var createMissingImporterMessage = function createMissingImporterMessage(specifier, importer) {
  return "missing importer to resolve relative specifier.\n--- specifier ---\n".concat(specifier, "\n--- importer ---\n").concat(importer);
};

var normalizeImportMap = function normalizeImportMap(importMap, href) {
  assertImportMap(importMap);

  if (typeof href !== "string") {
    throw new TypeError("href must be a string, got ".concat(href));
  }

  var imports = importMap.imports,
      scopes = importMap.scopes;
  return {
    imports: imports ? normalizeImports(imports, href) : undefined,
    scopes: scopes ? normalizeScopes(scopes, href) : undefined
  };
};

var normalizeImports = function normalizeImports(imports, href) {
  var importsNormalized = {};
  Object.keys(imports).forEach(function (importKey) {
    var importValue = imports[importKey];
    var importKeyNormalized = resolveSpecifier(importKey, href);
    var importValueNormalized = resolveSpecifier(importValue, href);
    importsNormalized[importKeyNormalized] = importValueNormalized;
  });
  return sortImports(importsNormalized);
};

var normalizeScopes = function normalizeScopes(scopes, href) {
  var scopesNormalized = {};
  Object.keys(scopes).forEach(function (scopeKey) {
    var scopeValue = scopes[scopeKey];
    var scopeKeyNormalized = resolveSpecifier(scopeKey, href);
    var scopeValueNormalized = normalizeImports(scopeValue, href);
    scopesNormalized[scopeKeyNormalized] = scopeValueNormalized;
  });
  return sortScopes(scopesNormalized);
};

var sortImports = function sortImports(imports) {
  var sortedImports = {};
  Object.keys(imports).sort(compareLengthOrLocaleCompare).forEach(function (name) {
    sortedImports[name] = imports[name];
  });
  return sortedImports;
};

var sortScopes = function sortScopes(scopes) {
  var sortedScopes = {};
  Object.keys(scopes).sort(compareLengthOrLocaleCompare).forEach(function (scopeName) {
    sortedScopes[scopeName] = sortImports(scopes[scopeName]);
  });
  return sortedScopes;
};

var compareLengthOrLocaleCompare = function compareLengthOrLocaleCompare(a, b) {
  return b.length - a.length || a.localeCompare(b);
};

// directly target the files because this code
var resolveImport = function resolveImport(_ref) {
  var specifier = _ref.specifier,
      importer = _ref.importer,
      importMap = _ref.importMap,
      _ref$defaultExtension = _ref.defaultExtension,
      defaultExtension = _ref$defaultExtension === void 0 ? true : _ref$defaultExtension;
  var specifierResolved = resolveSpecifier(specifier, importer);
  var specifierRemapped = importMap ? applyImportMap({
    importMap: importMap,
    href: specifierResolved,
    importerHref: importer
  }) : specifierResolved;

  if (typeof defaultExtension === "string") {
    var extension = pathnameToExtension(specifierRemapped);

    if (extension === "") {
      return "".concat(specifierRemapped).concat(defaultExtension);
    }
  }

  if (defaultExtension === true) {
    var _extension = pathnameToExtension(specifierRemapped);

    if (_extension === "") {
      if (importer) {
        var importerPathname = hrefToPathname(importer);
        var importerExtension = pathnameToExtension(importerPathname);
        return "".concat(specifierRemapped).concat(importerExtension);
      }
    }
  }

  return specifierRemapped;
};

/* eslint-disable */
// https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-modules-systemjs
var _require2$4 = nodeRequire("@babel/core"),
    template = _require2$4.template,
    t = _require2$4.types;

var _require3$1 = nodeRequire("@babel/helper-plugin-utils"),
    declare = _require3$1.declare;

var _require4 = nodeRequire("@babel/helper-hoist-variables"),
    hoistVariables = _require4.default;

var buildTemplate = template("\n  SYSTEM_REGISTER(MODULE_NAME, SOURCES, function (EXPORT_IDENTIFIER, CONTEXT_IDENTIFIER) {\n    \"use strict\";\n    BEFORE_BODY;\n    return {\n      setters: SETTERS,\n      execute: EXECUTE\n    };\n  });\n");
var buildExportAll = template("\n  for (var KEY in TARGET) {\n    if (KEY !== \"default\" && KEY !== \"__esModule\") EXPORT_OBJ[KEY] = TARGET[KEY];\n  }\n");

function constructExportCall(path, exportIdent, exportNames, exportValues, exportStarTarget) {
  var statements = [];

  if (exportNames.length === 1) {
    statements.push(t.expressionStatement(t.callExpression(exportIdent, [t.stringLiteral(exportNames[0]), exportValues[0]]))); // eslint-disable-next-line no-negated-condition
  } else if (!exportStarTarget) {
    var objectProperties = [];

    for (var i = 0; i < exportNames.length; i++) {
      var exportName = exportNames[i];
      var exportValue = exportValues[i];
      objectProperties.push(t.objectProperty(t.identifier(exportName), exportValue));
    }

    statements.push(t.expressionStatement(t.callExpression(exportIdent, [t.objectExpression(objectProperties)])));
  } else {
    var exportObj = path.scope.generateUid("exportObj");
    statements.push(t.variableDeclaration("var", [t.variableDeclarator(t.identifier(exportObj), t.objectExpression([]))]));
    statements.push(buildExportAll({
      KEY: path.scope.generateUidIdentifier("key"),
      EXPORT_OBJ: t.identifier(exportObj),
      TARGET: exportStarTarget
    }));

    for (var _i = 0; _i < exportNames.length; _i++) {
      var _exportName = exportNames[_i];
      var _exportValue = exportValues[_i];
      statements.push(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(t.identifier(exportObj), t.identifier(_exportName)), _exportValue)));
    }

    statements.push(t.expressionStatement(t.callExpression(exportIdent, [t.identifier(exportObj)])));
  }

  return statements;
}

var TYPE_IMPORT = "Import";
declare(function (api, options) {
  api.assertVersion(7);
  var _options$systemGlobal = options.systemGlobal,
      systemGlobal = _options$systemGlobal === void 0 ? "System" : _options$systemGlobal;
  var IGNORE_REASSIGNMENT_SYMBOL = Symbol();
  var reassignmentVisitor = {
    "AssignmentExpression|UpdateExpression": function AssignmentExpressionUpdateExpression(path) {
      if (path.node[IGNORE_REASSIGNMENT_SYMBOL]) return;
      path.node[IGNORE_REASSIGNMENT_SYMBOL] = true;
      var arg = path.get(path.isAssignmentExpression() ? "left" : "argument");

      if (arg.isObjectPattern() || arg.isArrayPattern()) {
        var exprs = [path.node];

        for (var _i2 = 0, _Object$keys = Object.keys(arg.getBindingIdentifiers()); _i2 < _Object$keys.length; _i2++) {
          var _name = _Object$keys[_i2];

          if (this.scope.getBinding(_name) !== path.scope.getBinding(_name)) {
            return;
          }

          var _exportedNames = this.exports[_name];
          if (!_exportedNames) return;
          var _iteratorNormalCompletion = true;
          var _didIteratorError = false;
          var _iteratorError = undefined;

          try {
            for (var _iterator = _exportedNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
              var _exportedName = _step.value;
              exprs.push(this.buildCall(_exportedName, t.identifier(_name)).expression);
            }
          } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion && _iterator.return != null) {
                _iterator.return();
              }
            } finally {
              if (_didIteratorError) {
                throw _iteratorError;
              }
            }
          }
        }

        path.replaceWith(t.sequenceExpression(exprs));
        return;
      }

      if (!arg.isIdentifier()) return;
      var name = arg.node.name; // redeclared in this scope

      if (this.scope.getBinding(name) !== path.scope.getBinding(name)) return;
      var exportedNames = this.exports[name];
      if (!exportedNames) return;
      var node = path.node; // if it is a non-prefix update expression (x++ etc)
      // then we must replace with the expression (_export('x', x + 1), x++)
      // in order to ensure the same update expression value

      var isPostUpdateExpression = path.isUpdateExpression({
        prefix: false
      });

      if (isPostUpdateExpression) {
        node = t.binaryExpression(node.operator[0], t.unaryExpression("+", t.cloneNode(node.argument)), t.numericLiteral(1));
      }

      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = exportedNames[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var _exportedName3 = _step2.value;
          node = this.buildCall(_exportedName3, node).expression;
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }

      if (isPostUpdateExpression) {
        node = t.sequenceExpression([node, path.node]);
      }

      path.replaceWith(node);
    }
  };
  return {
    name: "transform-modules-systemjs",
    visitor: {
      CallExpression: function CallExpression(path, state) {
        if (path.node.callee.type === TYPE_IMPORT) {
          path.replaceWith(t.callExpression(t.memberExpression(t.identifier(state.contextIdent), t.identifier("import")), path.node.arguments));
        }
      },
      MetaProperty: function MetaProperty(path, state) {
        if (path.node.meta.name === "import" && path.node.property.name === "meta") {
          path.replaceWith(t.memberExpression(t.identifier(state.contextIdent), t.identifier("meta")));
        }
      },
      ReferencedIdentifier: function ReferencedIdentifier(path, state) {
        if (path.node.name === "__moduleName" && !path.scope.hasBinding("__moduleName")) {
          path.replaceWith(t.memberExpression(t.identifier(state.contextIdent), t.identifier("id")));
        }
      },
      Program: {
        enter: function enter(path, state) {
          state.contextIdent = path.scope.generateUid("context");
        },
        exit: function exit(path, state) {
          var undefinedIdent = path.scope.buildUndefinedNode();
          var exportIdent = path.scope.generateUid("export");
          var contextIdent = state.contextIdent;
          var exportMap = Object.create(null);
          var modules = [];
          var beforeBody = [];
          var setters = [];
          var sources = [];
          var variableIds = [];
          var removedPaths = [];

          function addExportName(key, val) {
            exportMap[key] = exportMap[key] || [];
            exportMap[key].push(val);
          }

          function pushModule(source, key, specifiers) {
            var module;
            modules.forEach(function (m) {
              if (m.key === source) {
                module = m;
              }
            });

            if (!module) {
              modules.push(module = {
                key: source,
                imports: [],
                exports: []
              });
            }

            module[key] = module[key].concat(specifiers);
          }

          function buildExportCall(name, val) {
            return t.expressionStatement(t.callExpression(t.identifier(exportIdent), [t.stringLiteral(name), val]));
          }

          var exportNames = [];
          var exportValues = [];
          var body = path.get("body");
          var _iteratorNormalCompletion3 = true;
          var _didIteratorError3 = false;
          var _iteratorError3 = undefined;

          try {
            for (var _iterator3 = body[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
              var _path3 = _step3.value;

              if (_path3.isFunctionDeclaration()) {
                beforeBody.push(_path3.node);
                removedPaths.push(_path3);
              } else if (_path3.isClassDeclaration()) {
                variableIds.push(_path3.node.id);

                _path3.replaceWith(t.expressionStatement(t.assignmentExpression("=", t.cloneNode(_path3.node.id), t.toExpression(_path3.node))));
              } else if (_path3.isImportDeclaration()) {
                var source = _path3.node.source.value;
                pushModule(source, "imports", _path3.node.specifiers);

                for (var _i4 = 0, _Object$keys2 = Object.keys(_path3.getBindingIdentifiers()); _i4 < _Object$keys2.length; _i4++) {
                  var name = _Object$keys2[_i4];

                  _path3.scope.removeBinding(name);

                  variableIds.push(t.identifier(name));
                }

                _path3.remove();
              } else if (_path3.isExportAllDeclaration()) {
                pushModule(_path3.node.source.value, "exports", _path3.node);

                _path3.remove();
              } else if (_path3.isExportDefaultDeclaration()) {
                var declar = _path3.get("declaration");

                var id = declar.node.id;

                if (declar.isClassDeclaration()) {
                  if (id) {
                    exportNames.push("default");
                    exportValues.push(undefinedIdent);
                    variableIds.push(id);
                    addExportName(id.name, "default");

                    _path3.replaceWith(t.expressionStatement(t.assignmentExpression("=", t.cloneNode(id), t.toExpression(declar.node))));
                  } else {
                    exportNames.push("default");
                    exportValues.push(t.toExpression(declar.node));
                    removedPaths.push(_path3);
                  }
                } else if (declar.isFunctionDeclaration()) {
                  if (id) {
                    beforeBody.push(declar.node);
                    exportNames.push("default");
                    exportValues.push(t.cloneNode(id));
                    addExportName(id.name, "default");
                  } else {
                    exportNames.push("default");
                    exportValues.push(t.toExpression(declar.node));
                  }

                  removedPaths.push(_path3);
                } else {
                  _path3.replaceWith(buildExportCall("default", declar.node));
                }
              } else if (_path3.isExportNamedDeclaration()) {
                var _declar = _path3.get("declaration");

                if (_declar.node) {
                  _path3.replaceWith(_declar);

                  if (_path3.isFunction()) {
                    var node = _declar.node;
                    var _name2 = node.id.name;
                    addExportName(_name2, _name2);
                    beforeBody.push(node);
                    exportNames.push(_name2);
                    exportValues.push(t.cloneNode(node.id));
                    removedPaths.push(_path3);
                  } else if (_path3.isClass()) {
                    var _name3 = _declar.node.id.name;
                    exportNames.push(_name3);
                    exportValues.push(undefinedIdent);
                    variableIds.push(_declar.node.id);

                    _path3.replaceWith(t.expressionStatement(t.assignmentExpression("=", t.cloneNode(_declar.node.id), t.toExpression(_declar.node))));

                    addExportName(_name3, _name3);
                  } else {
                    for (var _i5 = 0, _Object$keys3 = Object.keys(_declar.getBindingIdentifiers()); _i5 < _Object$keys3.length; _i5++) {
                      var _name4 = _Object$keys3[_i5];
                      addExportName(_name4, _name4);
                    }
                  }
                } else {
                  var specifiers = _path3.node.specifiers;

                  if (specifiers && specifiers.length) {
                    if (_path3.node.source) {
                      pushModule(_path3.node.source.value, "exports", specifiers);

                      _path3.remove();
                    } else {
                      var nodes = [];
                      var _iteratorNormalCompletion6 = true;
                      var _didIteratorError6 = false;
                      var _iteratorError6 = undefined;

                      try {
                        for (var _iterator6 = specifiers[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
                          var _specifier2 = _step6.value;

                          var binding = _path3.scope.getBinding(_specifier2.local.name); // hoisted function export


                          if (binding && t.isFunctionDeclaration(binding.path.node)) {
                            exportNames.push(_specifier2.exported.name);
                            exportValues.push(t.cloneNode(_specifier2.local));
                          } // only globals also exported this way
                          else if (!binding) {
                              nodes.push(buildExportCall(_specifier2.exported.name, _specifier2.local));
                            }

                          addExportName(_specifier2.local.name, _specifier2.exported.name);
                        }
                      } catch (err) {
                        _didIteratorError6 = true;
                        _iteratorError6 = err;
                      } finally {
                        try {
                          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
                            _iterator6.return();
                          }
                        } finally {
                          if (_didIteratorError6) {
                            throw _iteratorError6;
                          }
                        }
                      }

                      _path3.replaceWithMultiple(nodes);
                    }
                  }
                }
              }
            }
          } catch (err) {
            _didIteratorError3 = true;
            _iteratorError3 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
                _iterator3.return();
              }
            } finally {
              if (_didIteratorError3) {
                throw _iteratorError3;
              }
            }
          }

          modules.forEach(function (specifiers) {
            var setterBody = [];
            var target = path.scope.generateUid(specifiers.key);
            var _iteratorNormalCompletion4 = true;
            var _didIteratorError4 = false;
            var _iteratorError4 = undefined;

            try {
              for (var _iterator4 = specifiers.imports[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                var _specifier = _step4.value;

                if (t.isImportNamespaceSpecifier(_specifier)) {
                  setterBody.push(t.expressionStatement(t.assignmentExpression("=", _specifier.local, t.identifier(target))));
                } else if (t.isImportDefaultSpecifier(_specifier)) {
                  _specifier = t.importSpecifier(_specifier.local, t.identifier("default"));
                }

                if (t.isImportSpecifier(_specifier)) {
                  setterBody.push(t.expressionStatement(t.assignmentExpression("=", _specifier.local, t.memberExpression(t.identifier(target), _specifier.imported))));
                }
              }
            } catch (err) {
              _didIteratorError4 = true;
              _iteratorError4 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
                  _iterator4.return();
                }
              } finally {
                if (_didIteratorError4) {
                  throw _iteratorError4;
                }
              }
            }

            if (specifiers.exports.length) {
              var _exportNames = [];
              var _exportValues = [];
              var hasExportStar = false;
              var _iteratorNormalCompletion5 = true;
              var _didIteratorError5 = false;
              var _iteratorError5 = undefined;

              try {
                for (var _iterator5 = specifiers.exports[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                  var _node = _step5.value;

                  if (t.isExportAllDeclaration(_node)) {
                    hasExportStar = true;
                  } else if (t.isExportSpecifier(_node)) {
                    _exportNames.push(_node.exported.name);

                    _exportValues.push(t.memberExpression(t.identifier(target), _node.local));
                  } else {// todo
                  }
                }
              } catch (err) {
                _didIteratorError5 = true;
                _iteratorError5 = err;
              } finally {
                try {
                  if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
                    _iterator5.return();
                  }
                } finally {
                  if (_didIteratorError5) {
                    throw _iteratorError5;
                  }
                }
              }

              setterBody = setterBody.concat(constructExportCall(path, t.identifier(exportIdent), _exportNames, _exportValues, hasExportStar ? t.identifier(target) : null));
            }

            sources.push(t.stringLiteral(specifiers.key));
            setters.push(t.functionExpression(null, [t.identifier(target)], t.blockStatement(setterBody)));
          });
          var moduleName = this.getModuleName();
          if (moduleName) moduleName = t.stringLiteral(moduleName);
          hoistVariables(path, function (id, name, hasInit) {
            variableIds.push(id);

            if (!hasInit) {
              exportNames.push(name);
              exportValues.push(undefinedIdent);
            }
          }, null);

          if (variableIds.length) {
            beforeBody.unshift(t.variableDeclaration("var", variableIds.map(function (id) {
              return t.variableDeclarator(id);
            })));
          }

          if (exportNames.length) {
            beforeBody = beforeBody.concat(constructExportCall(path, t.identifier(exportIdent), exportNames, exportValues, null));
          }

          path.traverse(reassignmentVisitor, {
            exports: exportMap,
            buildCall: buildExportCall,
            scope: path.scope
          });

          for (var _i3 = 0, _removedPaths = removedPaths; _i3 < _removedPaths.length; _i3++) {
            var _path2 = _removedPaths[_i3];

            _path2.remove();
          }

          path.node.body = [buildTemplate({
            SYSTEM_REGISTER: t.memberExpression(t.identifier(systemGlobal), t.identifier("register")),
            BEFORE_BODY: beforeBody,
            MODULE_NAME: moduleName,
            SETTERS: t.arrayExpression(setters),
            SOURCES: t.arrayExpression(sources),
            EXECUTE: t.functionExpression(null, [], t.blockStatement(path.node.body), false, options.topLevelAwait && programUsesTopLevelAwait(path)),
            EXPORT_IDENTIFIER: t.identifier(exportIdent),
            CONTEXT_IDENTIFIER: t.identifier(contextIdent)
          })];
        }
      }
    }
  };
});

var programUsesTopLevelAwait = function programUsesTopLevelAwait(path) {
  var hasTopLevelAwait = false;
  path.traverse({
    AwaitExpression: function AwaitExpression(path) {
      var parent = path.getFunctionParent();
      if (!parent || parent.type === "Program") hasTopLevelAwait = true;
    }
  });
  return hasTopLevelAwait;
};

// https://github.com/rburns/ansi-to-html/blob/master/src/ansi_to_html.js
// https://github.com/drudru/ansi_up/blob/master/ansi_up.js
var Convert = nodeRequire("ansi-to-html");

var _require2$5 = nodeRequire("@babel/helper-module-imports"),
    addSideEffect = _require2$5.addSideEffect;

var _require2$6 = nodeRequire("@babel/helper-module-imports"),
    addSideEffect$1 = _require2$6.addSideEffect;

var _require2$7 = nodeRequire("@babel/helper-module-imports"),
    addDefault = _require2$7.addDefault; // named import approach found here:

var _require2$8 = nodeRequire("@babel/core"),
    transformAsync = _require2$8.transformAsync,
    transformFromAstAsync = _require2$8.transformFromAstAsync;

var syntaxDynamicImport = nodeRequire("@babel/plugin-syntax-dynamic-import");

var syntaxImportMeta = nodeRequire("@babel/plugin-syntax-import-meta");

// eslint-disable-next-line consistent-return
var arrayWithoutHoles$1 = (function (arr) {
  if (Array.isArray(arr)) {
    var i = 0;
    var arr2 = new Array(arr.length);

    for (; i < arr.length; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }
});

// eslint-disable-next-line consistent-return
var iterableToArray$1 = (function (iter) {
  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
});

var nonIterableSpread$1 = (function () {
  throw new TypeError("Invalid attempt to spread non-iterable instance");
});

var _toConsumableArray$1 = (function (arr) {
  return arrayWithoutHoles$1(arr) || iterableToArray$1(arr) || nonIterableSpread$1();
});

// TODO: externalize this into '@dmail/helper'
// import { arrayWithout } from '@dmail/helper'
var arrayWithout = function arrayWithout(array, item) {
  var arrayWithoutItem = [];
  var i = 0;

  while (i < array.length) {
    var value = array[i];
    i++;

    if (value === item) {
      continue;
    }

    arrayWithoutItem.push(value);
  }

  return arrayWithoutItem;
};

var createCancelError = function createCancelError(reason) {
  var cancelError = new Error("canceled because ".concat(reason));
  cancelError.name = "CANCEL_ERROR";
  cancelError.reason = reason;
  return cancelError;
};
var isCancelError = function isCancelError(value) {
  return value && _typeof(value) === "object" && value.name === "CANCEL_ERROR";
};
var createCancellationSource = function createCancellationSource() {
  var requested = false;
  var cancelError;
  var registrationArray = [];

  var cancel = function cancel(reason) {
    if (requested) return;
    requested = true;
    cancelError = createCancelError(reason);
    var registrationArrayCopy = registrationArray.slice();
    registrationArray.length = 0;
    registrationArrayCopy.forEach(function (registration) {
      registration.callback(cancelError); // const removedDuringCall = registrationArray.indexOf(registration) === -1
    });
  };

  var register = function register(callback) {
    if (typeof callback !== "function") {
      throw new Error("callback must be a function, got ".concat(callback));
    }

    var existingRegistration = registrationArray.find(function (registration) {
      return registration.callback === callback;
    }); // don't register twice

    if (existingRegistration) {
      return existingRegistration;
    }

    var registration = {
      callback: callback,
      unregister: function unregister() {
        registrationArray = arrayWithout(registrationArray, registration);
      }
    };
    registrationArray = [registration].concat(_toConsumableArray$1(registrationArray));
    return registration;
  };

  var throwIfRequested = function throwIfRequested() {
    if (requested) {
      throw cancelError;
    }
  };

  return {
    token: {
      register: register,

      get cancellationRequested() {
        return requested;
      },

      throwIfRequested: throwIfRequested
    },
    cancel: cancel
  };
};
var createCancellationToken = function createCancellationToken() {
  var register = function register(callback) {
    if (typeof callback !== "function") {
      throw new Error("callback must be a function, got ".concat(callback));
    }

    return {
      callback: callback,
      unregister: function unregister() {}
    };
  };

  var throwIfRequested = function throwIfRequested() {
    return undefined;
  };

  return {
    register: register,
    cancellationRequested: false,
    throwIfRequested: throwIfRequested
  };
};

var objectWithoutPropertiesLoose = (function (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;
});

var _objectWithoutProperties = (function (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;
});

var createOperation = function createOperation(_ref) {
  var _ref$cancellationToke = _ref.cancellationToken,
      cancellationToken = _ref$cancellationToke === void 0 ? createCancellationToken() : _ref$cancellationToke,
      start = _ref.start,
      rest = _objectWithoutProperties(_ref, ["cancellationToken", "start"]);

  ensureExactParameters(rest);
  cancellationToken.throwIfRequested();
  var promise = new Promise(function (resolve) {
    resolve(start());
  });
  var cancelPromise = new Promise(function (resolve, reject) {
    var cancelRegistration = cancellationToken.register(function (cancelError) {
      cancelRegistration.unregister();
      reject(cancelError);
    });
    promise.then(cancelRegistration.unregister, function () {});
  });
  var operationPromise = Promise.race([promise, cancelPromise]);
  return operationPromise;
};

var ensureExactParameters = function ensureExactParameters(extraParameters) {
  var extraParamNames = Object.keys(extraParameters);
  if (extraParamNames.length) throw new Error("createOperation expect only cancellationToken, start. Got ".concat(extraParamNames));
};

var catchAsyncFunctionCancellation = function catchAsyncFunctionCancellation(asyncFunction) {
  return asyncFunction().catch(function (error) {
    if (isCancelError(error)) return;
    throw error;
  });
};
var createProcessInterruptionCancellationToken = function createProcessInterruptionCancellationToken() {
  var SIGINTCancelSource = createCancellationSource();
  process.on("SIGINT", function () {
    return SIGINTCancelSource.cancel("process interruption");
  });
  return SIGINTCancelSource.token;
};

var jsenvBundlingProjectPath;

if (typeof __filename === "string") {
  jsenvBundlingProjectPath = path.resolve(__filename, "../../../"); // get ride of dist/node/main.js
} else {
  var selfPathname$1 = hrefToPathname(url);
  var selfPath$1 = pathnameToOperatingSystemPath(selfPathname$1);
  jsenvBundlingProjectPath = path.resolve(selfPath$1, "../../"); // get ride of src/JSENV_PATH.js
}
var jsenvBundlingProjectPathname = operatingSystemPathToPathname(jsenvBundlingProjectPath);
var jsenvBundlingRelativePathInception = function jsenvBundlingRelativePathInception(_ref) {
  var jsenvBundlingRelativePath = _ref.jsenvBundlingRelativePath,
      projectPathname = _ref.projectPathname;
  var jsenvPathname = "".concat(jsenvBundlingProjectPathname).concat(jsenvBundlingRelativePath);
  var relativePath = pathnameToRelativePath(jsenvPathname, projectPathname);
  return relativePath;
};

function _await$4(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$4(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var assertFolder = _async$4(function (path) {
  return _await$4(pathToFilesystemEntry(path), function (filesystemEntry) {
    if (!filesystemEntry) {
      throw new Error("folder not found on filesystem.\npath: ".concat(path));
    }

    var type = filesystemEntry.type;

    if (type !== "folder") {
      throw new Error("folder expected but found something else on filesystem.\npath: ".concat(path, "\nfound: ").concat(type));
    }
  });
});
var assertFile = _async$4(function (path) {
  return _await$4(pathToFilesystemEntry(path), function (filesystemEntry) {
    if (!filesystemEntry) {
      throw new Error("file not found on filesystem.\npath: ".concat(path));
    }

    var type = filesystemEntry.type;

    if (type !== "file") {
      throw new Error("file expected but found something else on filesystem.\npath: ".concat(path, "\nfound: ").concat(type));
    }
  });
});

var pathToFilesystemEntry = function pathToFilesystemEntry(path) {
  return new Promise(function (resolve, reject) {
    fs.stat(path, function (error, stats) {
      if (error) {
        if (error.code === "ENOENT") resolve(null);else reject(error);
      } else {
        resolve({
          type: statsToEntry(stats),
          stats: stats
        });
      }
    });
  });
};

var statsToEntry = function statsToEntry(stats) {
  if (stats.isFile()) {
    return "file";
  }

  if (stats.isDirectory()) {
    return "folder";
  }

  return "other";
};

var assertImportMap$1 = function assertImportMap(value) {
  if (value === null) {
    throw new TypeError("an importMap must be an object, got null");
  }

  var type = _typeof$1(value);

  if (type !== "object") {
    throw new TypeError("an importMap must be an object, received ".concat(value));
  }

  if (Array.isArray(value)) {
    throw new TypeError("an importMap must be an object, received array ".concat(value));
  }
};

// https://github.com/WICG/import-maps/blob/93f94c6dfb268bde3009644b65580fb2fbb98fcf/reference-implementation/lib/parser.js#L42
var sortImportMap = function sortImportMap(importMap) {
  assertImportMap$1(importMap);
  var imports = importMap.imports,
      scopes = importMap.scopes;
  var orderedImportMap = {
    imports: imports ? sortImportMapImports(imports) : {},
    scopes: scopes ? sortImportMapScopes(scopes) : {}
  };
  return orderedImportMap;
};

var sortImportMapImports = function sortImportMapImports(imports) {
  var sortedImports = {};
  Object.keys(imports).sort(compareLengthOrLocaleCompare$1).forEach(function (name) {
    sortedImports[name] = imports[name];
  });
  return sortedImports;
};

var sortImportMapScopes = function sortImportMapScopes(scopes) {
  var sortedScopes = {};
  Object.keys(scopes).sort(compareLengthOrLocaleCompare$1).forEach(function (scopeName) {
    sortedScopes[scopeName] = sortScopedImports(scopes[scopeName]);
  });
  return sortedScopes;
};

var compareLengthOrLocaleCompare$1 = function compareLengthOrLocaleCompare(a, b) {
  return b.length - a.length || a.localeCompare(b);
};

var sortScopedImports = function sortScopedImports(scopedImports) {
  var compareScopedImport = function compareScopedImport(a, b) {
    // const aIsRoot = a === "/"
    // const bIsRoot = b === "/"
    // if (aIsRoot && !bIsRoot) return 1
    // if (!aIsRoot && bIsRoot) return -1
    // if (aIsRoot && bIsRoot) return 0
    // const aIsScope = a === scope
    // const bIsScope = b === scope
    // if (aIsScope && !bIsScope) return 1
    // if (!aIsScope && bIsScope) return -1
    // if (aIsScope && bIsScope) return 0
    return compareLengthOrLocaleCompare$1(a, b);
  };

  var sortedScopedImports = {};
  Object.keys(scopedImports).sort(compareScopedImport).forEach(function (name) {
    sortedScopedImports[name] = scopedImports[name];
  });
  return sortedScopedImports;
};

var pathnameToDirname$1 = function pathnameToDirname(pathname) {
  var slashLastIndex = pathname.lastIndexOf("/");
  if (slashLastIndex === -1) return "";
  return pathname.slice(0, slashLastIndex);
};

function _await$5(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$5(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var readPackageData = _async$5(function (_ref) {
  var path = _ref.path;
  return _await$5(fileRead(path), function (packageString) {
    var packageData = JSON.parse(packageString);
    return packageData;
  });
});

function _await$6(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$6(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

function _catch(body, recover) {
  try {
    var result = body();
  } catch (e) {
    return recover(e);
  }

  if (result && result.then) {
    return result.then(void 0, recover);
  }

  return result;
}

var resolveNodeModule = _async$6(function (_ref) {
  var rootPathname = _ref.rootPathname,
      packagePathname = _ref.packagePathname,
      packageData = _ref.packageData,
      dependencyName = _ref.dependencyName,
      dependencyVersionPattern = _ref.dependencyVersionPattern,
      dependencyType = _ref.dependencyType,
      onWarn = _ref.onWarn;
  var packageFolderPathname = pathnameToDirname$1(packagePathname);
  var packageFolderRelativePath = pathnameToRelativePathname(packageFolderPathname, rootPathname);
  var nodeModuleCandidateArray = [].concat(_toConsumableArray(getCandidateArrayFromPackageFolder(packageFolderRelativePath)), ["node_modules"]);
  return _await$6(firstOperationMatching({
    array: nodeModuleCandidateArray,
    start: _async$6(function (nodeModuleCandidate) {
      var packagePathname = "".concat(rootPathname, "/").concat(nodeModuleCandidate, "/").concat(dependencyName, "/package.json");
      return _catch(function () {
        return _await$6(readPackageData({
          path: pathnameToOperatingSystemPath(packagePathname)
        }), function (packageData) {
          return {
            packagePathname: packagePathname,
            packageData: packageData
          };
        });
      }, function (e) {
        if (e.code === "ENOENT") {
          return {};
        }

        if (e.name === "SyntaxError") {
          throw createDependencyPackageParsingError({
            parsingError: e,
            packagePathname: packagePathname
          });
        }

        throw e;
      });
    }),
    predicate: function predicate(_ref2) {
      var packageData = _ref2.packageData;
      return Boolean(packageData);
    }
  }), function (result) {
    if (!result) {
      onWarn({
        code: "DEPENDENCY_NOT_FOUND",
        message: createDendencyNotFoundMessage({
          dependencyName: dependencyName,
          dependencyType: dependencyType,
          dependencyVersionPattern: dependencyVersionPattern,
          packagePathname: packagePathname,
          packageData: packageData
        }),
        data: {
          packagePathname: packagePathname,
          packageData: packageData,
          dependencyName: dependencyName,
          dependencyType: dependencyType
        }
      });
    }

    return result;
  });
});

var getCandidateArrayFromPackageFolder = function getCandidateArrayFromPackageFolder(packageFolderRelativePath) {
  if (packageFolderRelativePath === "") return [];
  var candidateArray = [];
  var relativeFolderNameArray = packageFolderRelativePath.split("/node_modules/"); // remove the first empty string

  relativeFolderNameArray.shift();
  var i = relativeFolderNameArray.length;

  while (i--) {
    candidateArray.push("node_modules/".concat(relativeFolderNameArray.slice(0, i + 1).join("/node_modules/"), "/node_modules"));
  }

  return candidateArray;
};

var createDependencyPackageParsingError = function createDependencyPackageParsingError(_ref3) {
  var parsingError = _ref3.parsingError,
      packagePathname = _ref3.packagePathname;
  return new SyntaxError("error while parsing dependency package.json.\n--- parsing error message ---\n".concat(parsingError.message, "\n--- package.json path ---\n").concat(pathnameToOperatingSystemPath(packagePathname), "\n"));
};

var createDendencyNotFoundMessage = function createDendencyNotFoundMessage(_ref4) {
  var dependencyName = _ref4.dependencyName,
      dependencyType = _ref4.dependencyType,
      dependencyVersionPattern = _ref4.dependencyVersionPattern,
      packageData = _ref4.packageData,
      packagePathname = _ref4.packagePathname;
  return "cannot find a ".concat(dependencyType, ".\n--- ").concat(dependencyType, " ---\n").concat(dependencyName, "@").concat(dependencyVersionPattern, "\n--- required by ---\n").concat(packageData.name, "@").concat(packageData.version, "\n--- package.json path ---\n").concat(pathnameToOperatingSystemPath(packagePathname), "\n");
};

function _await$7(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _invoke(body, then) {
  var result = body();

  if (result && result.then) {
    return result.then(then);
  }

  return then(result);
}

function _async$7(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var resolvePackageMain = function resolvePackageMain(_ref) {
  var packageData = _ref.packageData,
      packagePathname = _ref.packagePathname,
      onWarn = _ref.onWarn;

  if ("module" in packageData) {
    return resolveMainFile({
      from: "module",
      main: packageData.module,
      packagePathname: packagePathname,
      onWarn: onWarn
    });
  }

  if ("jsnext:main" in packageData) {
    return resolveMainFile({
      from: "jsnext:main",
      main: packageData["jsnext:main"],
      packagePathname: packagePathname,
      onWarn: onWarn
    });
  }

  if ("main" in packageData) {
    return resolveMainFile({
      from: "main",
      main: packageData.main,
      packagePathname: packagePathname,
      onWarn: onWarn
    });
  }

  return resolveMainFile({
    from: "default",
    main: "index",
    packagePathname: packagePathname,
    onWarn: onWarn
  });
};
var extensionCandidateArray = ["js", "json", "node"];

var resolveMainFile = _async$7(function (_ref2) {
  var _exit = false;
  var main = _ref2.main,
      packagePathname = _ref2.packagePathname,
      onWarn = _ref2.onWarn;
  // main is explicitely empty meaning
  // it is assumed that we should not find a file
  if (main === "") return "";
  if (main.slice(0, 2) === "./") main = main.slice(2);
  if (main[0] === "/") main = main.slice(1);
  var packageDirname = pathnameToDirname$1(packagePathname);
  var extension = path.extname(main);
  return _invoke(function () {
    if (extension === "") {
      var fileWithoutExtensionPathname = "".concat(packageDirname, "/").concat(main);
      return _await$7(firstOperationMatching({
        array: extensionCandidateArray,
        start: _async$7(function (extensionCandidate) {
          var path = pathnameToOperatingSystemPath("".concat(fileWithoutExtensionPathname, ".").concat(extensionCandidate));
          return _await$7(pathLeadsToAFile(path), function (isFile) {
            return isFile ? extensionCandidate : null;
          });
        }),
        predicate: function predicate(extension) {
          return Boolean(extension);
        }
      }), function (extensionLeadingToFile) {
        if (extensionLeadingToFile) {
          _exit = true;
          return "".concat(main, ".").concat(extensionLeadingToFile);
        }

        onWarn({
          code: "MAIN_FILE_NOT_FOUND",
          message: createMainFileNotFoundMessage({
            mainPathname: fileWithoutExtensionPathname,
            packagePathname: packagePathname
          }),
          data: {
            main: main,
            packagePathname: packagePathname
          }
        });
        _exit = true;
        return "".concat(main, ".js");
      });
    }
  }, function (_result) {
    if (_exit) return _result;
    var mainPathname = "".concat(packageDirname, "/").concat(main);
    return _await$7(pathLeadsToAFile(mainPathname), function (isFile) {
      if (!isFile) {
        onWarn({
          code: "MAIN_FILE_NOT_FOUND",
          message: createMainFileNotFoundMessage({
            mainPathname: mainPathname,
            packagePathname: packagePathname
          }),
          data: {
            main: main,
            packagePathname: packagePathname
          }
        });
      }

      return main;
    });
  });
});

var pathLeadsToAFile = function pathLeadsToAFile(path) {
  return new Promise(function (resolve, reject) {
    fs.stat(path, function (error, statObject) {
      if (error) {
        if (error.code === "ENOENT") resolve(false);else reject(error);
      } else {
        resolve(statObject.isFile());
      }
    });
  });
}; // we know in advance this remapping does not lead to an actual file.
// we only warn because we have no guarantee this remapping will actually be used
// in the codebase.


var createMainFileNotFoundMessage = function createMainFileNotFoundMessage(_ref3) {
  var mainPathname = _ref3.mainPathname,
      packagePathname = _ref3.packagePathname;
  return "cannot find a module main file.\n--- extensions tried ---\n".concat(extensionCandidateArray.join(","), "\n--- main path ---\n").concat(pathnameToOperatingSystemPath(mainPathname), "\n--- package.json path ---\n").concat(pathnameToOperatingSystemPath(packagePathname));
};

function _await$8(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$8(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

function _empty$2() {}

function _awaitIgnored$1(value, direct) {
  if (!direct) {
    return value && value.then ? value.then(_empty$2) : Promise.resolve();
  }
}

var generateImportMapForPackage = _async$8(function (_ref) {
  var projectPath = _ref.projectPath,
      _ref$rootProjectPath = _ref.rootProjectPath,
      rootProjectPath = _ref$rootProjectPath === void 0 ? projectPath : _ref$rootProjectPath,
      _ref$includeDevDepend = _ref.includeDevDependencies,
      includeDevDependencies = _ref$includeDevDepend === void 0 ? false : _ref$includeDevDepend,
      _ref$onWarn = _ref.onWarn,
      onWarn = _ref$onWarn === void 0 ? function (_ref2) {
    var message = _ref2.message;
    console.warn(message);
  } : _ref$onWarn;
  var projectPathname = operatingSystemPathToPathname(projectPath);
  var projectPackagePathname = "".concat(projectPathname, "/package.json");
  var rootProjectPathname = operatingSystemPathToPathname(rootProjectPath);
  var rootImporterName = path.basename(rootProjectPathname);
  var rootPackagePathname = "".concat(rootProjectPathname, "/package.json");
  var imports = {};
  var scopes = {};
  var seen = {};

  var markPackageAsSeen = function markPackageAsSeen(packagePathname, importerPackagePathname) {
    if (packagePathname in seen) {
      seen[packagePathname].push(importerPackagePathname);
    } else {
      seen[packagePathname] = [importerPackagePathname];
    }
  };

  var packageIsSeen = function packageIsSeen(packagePathname, importerPackagePathname) {
    return packagePathname in seen && seen[packagePathname].includes(importerPackagePathname);
  };

  var visit = function visit(_ref3) {
    var packagePathname = _ref3.packagePathname,
        packageData = _ref3.packageData,
        includeDevDependencies = _ref3.includeDevDependencies,
        packageName = _ref3.packageName,
        importerPackagePathname = _ref3.importerPackagePathname;
    return _await$8(visitPackage({
      packagePathname: packagePathname,
      packageData: packageData,
      packageName: packageName,
      importerPackagePathname: importerPackagePathname
    }), function () {
      return _awaitIgnored$1(visitDependencies({
        packagePathname: packagePathname,
        packageData: packageData,
        includeDevDependencies: includeDevDependencies
      }));
    });
  };

  var visitPackage = _async$8(function (_ref4) {
    var packagePathname = _ref4.packagePathname,
        packageData = _ref4.packageData,
        packageName = _ref4.packageName,
        importerPackagePathname = _ref4.importerPackagePathname;
    var packagePathInfo = computePackagePathInfo({
      packagePathname: packagePathname,
      packageName: packageName,
      importerPackagePathname: importerPackagePathname
    });
    return _await$8(visitPackageMain({
      packagePathname: packagePathname,
      packageName: packageName,
      packageData: packageData,
      packagePathInfo: packagePathInfo
    }), function () {
      if ("imports" in packageData) {
        visitPackageImports({
          packagePathname: packagePathname,
          packageName: packageName,
          packageData: packageData,
          packagePathInfo: packagePathInfo
        });
      }

      if ("exports" in packageData) {
        visitPackageExports({
          packagePathname: packagePathname,
          packageName: packageName,
          packageData: packageData,
          packagePathInfo: packagePathInfo
        });
      }
    });
  });

  var visitPackageMain = _async$8(function (_ref5) {
    var packagePathname = _ref5.packagePathname,
        packageData = _ref5.packageData,
        packageName = _ref5.packageName,
        _ref5$packagePathInfo = _ref5.packagePathInfo,
        packageIsRoot = _ref5$packagePathInfo.packageIsRoot,
        packageIsProject = _ref5$packagePathInfo.packageIsProject,
        importerPackageIsRoot = _ref5$packagePathInfo.importerPackageIsRoot,
        importerName = _ref5$packagePathInfo.importerName,
        actualRelativePath = _ref5$packagePathInfo.actualRelativePath,
        expectedRelativePath = _ref5$packagePathInfo.expectedRelativePath;
    if (packageIsRoot) return;
    if (packageIsProject) return;
    return _await$8(resolvePackageMain({
      packagePathname: packagePathname,
      packageData: packageData,
      onWarn: function onWarn() {}
    }), function (main) {
      if (!main) return;
      var from = packageName;
      var to = "".concat(actualRelativePath, "/").concat(main);

      if (importerPackageIsRoot) {
        addImportMapping({
          from: from,
          to: to
        });
      } else {
        addScopedImportMapping({
          scope: "/".concat(importerName, "/"),
          from: from,
          to: to
        });
      }

      if (actualRelativePath !== expectedRelativePath) {
        addScopedImportMapping({
          scope: "/".concat(importerName, "/"),
          from: from,
          to: to
        });
      }
    }); // it's possible to have no main
    // like { main: "" } in package.json
    // or a main that does not lead to an actual file
  });

  var visitPackageImports = function visitPackageImports(_ref6) {
    var packagePathname = _ref6.packagePathname,
        packageData = _ref6.packageData,
        packagePathInfo = _ref6.packagePathInfo;
    var packageImports = packageData.imports;

    if (_typeof$1(packageImports) !== "object" || packageImports === null) {
      onWarn(createUnexpectedPackageImportsWarning({
        packageImports: packageImports,
        packagePathname: packagePathname
      }));
      return;
    }

    var packageIsRoot = packagePathInfo.packageIsRoot,
        actualRelativePath = packagePathInfo.actualRelativePath;
    Object.keys(packageImports).forEach(function (key) {
      var resolvedKey = resolvePathInPackage(key, packagePathname);
      if (!resolvedKey) return;
      var resolvedValue = resolvePathInPackage(packageImports[key], packagePathname);
      if (!resolvedValue) return;

      if (packageIsRoot) {
        addImportMapping({
          from: resolvedKey,
          to: resolvedValue
        });
      } else {
        addScopedImportMapping({
          scope: "".concat(actualRelativePath, "/"),
          from: resolvedKey,
          to: "".concat(actualRelativePath).concat(resolvedValue)
        });
      }
    });

    if (!packageIsRoot) {
      // ensureImportsScopedInsidePackage
      addScopedImportMapping({
        scope: "".concat(actualRelativePath, "/"),
        from: "".concat(actualRelativePath, "/"),
        to: "".concat(actualRelativePath, "/")
      });
    }
  };

  var visitPackageExports = function visitPackageExports(_ref7) {
    var packagePathname = _ref7.packagePathname,
        packageName = _ref7.packageName,
        packageData = _ref7.packageData,
        _ref7$packagePathInfo = _ref7.packagePathInfo,
        importerName = _ref7$packagePathInfo.importerName,
        packageIsRoot = _ref7$packagePathInfo.packageIsRoot,
        actualRelativePath = _ref7$packagePathInfo.actualRelativePath,
        expectedRelativePath = _ref7$packagePathInfo.expectedRelativePath;
    if (packageIsRoot) return;
    var packageExports = packageData.exports;

    if (_typeof$1(packageExports) !== "object" || packageExports === null) {
      onWarn(createUnexpectedPackageExportsWarning({
        packageExports: packageExports,
        packagePathname: packagePathname
      }));
      return;
    }

    Object.keys(packageExports).forEach(function (key) {
      var resolvedKey = resolvePathInPackage(key, packagePathname);
      if (!resolvedKey) return;
      var resolvedValue = resolvePathInPackage(packageExports[key], packagePathname);
      if (!resolvedValue) return;
      var from = "".concat(packageName).concat(resolvedKey);
      var to = "".concat(actualRelativePath).concat(resolvedValue);

      if (importerName === rootImporterName) {
        addImportMapping({
          from: from,
          to: to
        });
      } else {
        addScopedImportMapping({
          scope: "/".concat(importerName, "/"),
          from: from,
          to: to
        });
      }

      if (actualRelativePath !== expectedRelativePath) {
        addScopedImportMapping({
          scope: "/".concat(importerName, "/"),
          from: from,
          to: to
        });
      }
    });
  };

  var visitDependencies = _async$8(function (_ref8) {
    var packagePathname = _ref8.packagePathname,
        packageData = _ref8.packageData,
        includeDevDependencies = _ref8.includeDevDependencies;
    var dependencyMap = {};
    var _packageData$dependen = packageData.dependencies,
        dependencies = _packageData$dependen === void 0 ? {} : _packageData$dependen;
    Object.keys(dependencies).forEach(function (dependencyName) {
      dependencyMap[dependencyName] = {
        type: "dependency",
        versionPattern: dependencies[dependencyName]
      };
    });
    var _packageData$peerDepe = packageData.peerDependencies,
        peerDependencies = _packageData$peerDepe === void 0 ? {} : _packageData$peerDepe;
    Object.keys(peerDependencies).forEach(function (dependencyName) {
      dependencyMap[dependencyName] = {
        type: "peerDependency",
        versionPattern: peerDependencies[dependencyName]
      };
    });
    var isProjectPackage = packagePathname === projectPackagePathname;

    if (includeDevDependencies && isProjectPackage) {
      var _packageData$devDepen = packageData.devDependencies,
          devDependencies = _packageData$devDepen === void 0 ? {} : _packageData$devDepen;
      Object.keys(devDependencies).forEach(function (dependencyName) {
        if (!dependencyMap.hasOwnProperty(dependencyName)) {
          dependencyMap[dependencyName] = {
            type: "devDependency",
            versionPattern: devDependencies[dependencyName]
          };
        }
      });
    }

    return _awaitIgnored$1(Promise.all(Object.keys(dependencyMap).map(_async$8(function (dependencyName) {
      var dependency = dependencyMap[dependencyName];
      return _awaitIgnored$1(visitDependency({
        packagePathname: packagePathname,
        packageData: packageData,
        dependencyName: dependencyName,
        dependencyType: dependency.type,
        dependencyVersionPattern: dependency.versionPattern
      }));
    }))));
  });

  var visitDependency = _async$8(function (_ref9) {
    var packagePathname = _ref9.packagePathname,
        packageData = _ref9.packageData,
        dependencyName = _ref9.dependencyName,
        dependencyType = _ref9.dependencyType,
        dependencyVersionPattern = _ref9.dependencyVersionPattern;
    return _await$8(findDependency({
      packagePathname: packagePathname,
      packageData: packageData,
      dependencyName: dependencyName,
      dependencyType: dependencyType,
      dependencyVersionPattern: dependencyVersionPattern
    }), function (dependencyData) {
      if (!dependencyData) {
        return;
      }

      var dependencyPackagePathname = dependencyData.packagePathname,
          dependencyPackageData = dependencyData.packageData;

      if (packageIsSeen(dependencyPackagePathname, packagePathname)) {
        return;
      }

      markPackageAsSeen(dependencyPackagePathname, packagePathname);
      return _awaitIgnored$1(visit({
        packagePathname: dependencyPackagePathname,
        packageData: dependencyPackageData,
        packageName: dependencyName,
        importerPackagePathname: packagePathname
      }));
    });
  });

  var computePackagePathInfo = function computePackagePathInfo(_ref10) {
    var packagePathname = _ref10.packagePathname,
        packageName = _ref10.packageName,
        importerPackagePathname = _ref10.importerPackagePathname;
    var packageIsRoot = packagePathname === rootPackagePathname;
    var packageIsProject = packagePathname === projectPackagePathname;
    var importerPackageIsRoot = importerPackagePathname === rootPackagePathname;
    var importerPackageIsProject = importerPackagePathname === projectPackagePathname;
    var importerName = importerPackageIsRoot ? rootImporterName : pathnameToDirname$1(pathnameToRelativePathname(importerPackagePathname, rootProjectPathname)).slice(1);
    var actualPathname = pathnameToDirname$1(packagePathname);
    var actualRelativePath = pathnameToRelativePathname(actualPathname, rootProjectPathname);
    var expectedPathname;

    if (packageIsProject && !packageIsRoot) {
      expectedPathname = pathnameToDirname$1(importerPackagePathname);
    } else {
      expectedPathname = "".concat(pathnameToDirname$1(importerPackagePathname), "/node_modules/").concat(packageName);
    }

    var expectedRelativePath = pathnameToRelativePathname(expectedPathname, rootProjectPathname);
    return {
      importerPackageIsRoot: importerPackageIsRoot,
      importerPackageIsProject: importerPackageIsProject,
      importerName: importerName,
      packageIsRoot: packageIsRoot,
      packageIsProject: packageIsProject,
      actualRelativePath: actualRelativePath,
      expectedRelativePath: expectedRelativePath
    };
  };

  var resolvePathInPackage = function resolvePathInPackage(path, packagePathname) {
    if (path[0] === "/") return path;
    if (path.slice(0, 2) === "./") return path.slice(1);
    onWarn(createInvalidPackageRelativePathWarning({
      path: path,
      packagePathname: packagePathname
    }));
    return "";
  };

  var addImportMapping = function addImportMapping(_ref11) {
    var from = _ref11.from,
        to = _ref11.to;

    // we could think it's useless to remap from with to
    // however it can be used to ensure a weaker remapping
    // does not win over this specific file or folder
    if (from === to) {
      /**
       * however remapping '/' to '/' is truly useless
       * moreover it would make wrapImportMap create something like
       * {
       *   imports: {
       *     "/": "/.dist/best/"
       *   }
       * }
       * that would append the wrapped folder twice
       * */
      if (from === "/") return;
    }

    imports[from] = to;
  };

  var addScopedImportMapping = function addScopedImportMapping(_ref12) {
    var scope = _ref12.scope,
        from = _ref12.from,
        to = _ref12.to;
    scopes[scope] = _objectSpread({}, scopes[scope] || {}, _defineProperty$1({}, from, to));
  };

  var dependenciesCache = {};

  var findDependency = function findDependency(_ref13) {
    var packagePathname = _ref13.packagePathname,
        packageData = _ref13.packageData,
        dependencyName = _ref13.dependencyName,
        dependencyType = _ref13.dependencyType,
        dependencyVersionPattern = _ref13.dependencyVersionPattern;

    if (packagePathname in dependenciesCache === false) {
      dependenciesCache[packagePathname] = {};
    }

    if (dependencyName in dependenciesCache[packagePathname]) {
      return dependenciesCache[packagePathname][dependencyName];
    }

    var dependencyPromise = resolveNodeModule({
      rootPathname: rootProjectPathname,
      packagePathname: packagePathname,
      packageData: packageData,
      dependencyName: dependencyName,
      dependencyType: dependencyType,
      dependencyVersionPattern: dependencyVersionPattern,
      onWarn: onWarn
    });
    dependenciesCache[packagePathname][dependencyName] = dependencyPromise;
    return dependencyPromise;
  };

  return _await$8(readPackageData({
    path: pathnameToOperatingSystemPath(projectPackagePathname),
    onWarn: onWarn
  }), function (projectPackageData) {
    markPackageAsSeen(projectPackagePathname, projectPackagePathname);
    return _await$8(visit({
      packagePathname: projectPackagePathname,
      packageData: projectPackageData,
      includeDevDependencies: includeDevDependencies,
      packageName: projectPackageData.name,
      importerPackagePathname: projectPackagePathname
    }), function () {
      return sortImportMap({
        imports: imports,
        scopes: scopes
      });
    });
  });
});

var createInvalidPackageRelativePathWarning = function createInvalidPackageRelativePathWarning(_ref14) {
  var path = _ref14.path,
      packagePathname = _ref14.packagePathname;
  return {
    code: "INVALID_PATH_RELATIVE_TO_PACKAGE",
    message: "\ninvalid path relative to package.\n--- path ---\n".concat(path, "\n--- package.json path ---\n").concat(pathnameToOperatingSystemPath(packagePathname), "\n"),
    data: {
      packagePathname: packagePathname,
      path: path
    }
  };
};

var createUnexpectedPackageImportsWarning = function createUnexpectedPackageImportsWarning(_ref15) {
  var packageImports = _ref15.packageImports,
      packagePathname = _ref15.packagePathname;
  return {
    code: "UNEXPECTED_PACKAGE_IMPORTS",
    message: "\npackage.imports must be an object.\n--- package.json imports ---\n".concat(packageImports, "\n--- package.json path ---\n").concat(pathnameToOperatingSystemPath(packagePathname), "\n"),
    data: {
      packagePathname: packagePathname,
      packageImports: packageImports
    }
  };
};

var createUnexpectedPackageExportsWarning = function createUnexpectedPackageExportsWarning(_ref16) {
  var packageExports = _ref16.packageExports,
      packagePathname = _ref16.packagePathname;
  return {
    code: "UNEXPECTED_PACKAGE_EXPORTS",
    message: "\npackage.exports must be an object.\n--- package.json exports ---\n".concat(packageExports, "\n--- package.json path ---\n").concat(pathnameToOperatingSystemPath(packagePathname), "\n"),
    data: {
      packagePathname: packagePathname,
      packageExports: packageExports
    }
  };
};

// https://github.com/cfware/babel-plugin-bundled-import-meta/blob/master/index.js
var _require2$9 = nodeRequire("@babel/helper-module-imports"),
    addNamed = _require2$9.addNamed;

var createImportMetaUrlNamedImportBabelPlugin = function createImportMetaUrlNamedImportBabelPlugin(_ref) {
  var importMetaFacadePath = _ref.importMetaFacadePath;
  return function () {
    return {
      visitor: {
        Program: function Program(programPath) {
          var metaPropertyMap = {};
          programPath.traverse({
            MemberExpression: function MemberExpression(path) {
              var node = path.node;
              var object = node.object;
              if (object.type !== "MetaProperty") return;
              var objectProperty = object.property;
              if (objectProperty.name !== "meta") return;
              var property = node.property;
              var name = property.name;

              if (name in metaPropertyMap) {
                metaPropertyMap[name].push(path);
              } else {
                metaPropertyMap[name] = [path];
              }
            }
          });
          Object.keys(metaPropertyMap).forEach(function (propertyName) {
            var importMetaPropertyId = propertyName;
            var result = addNamed(programPath, importMetaPropertyId, importMetaFacadePath);
            metaPropertyMap[propertyName].forEach(function (path) {
              path.replaceWith(result);
            });
          });
        }
      }
    };
  };
};

var generateBabelPluginMapOption = function generateBabelPluginMapOption(_ref) {
  var format = _ref.format,
      babelPluginMap = _ref.babelPluginMap,
      featureNameArray = _ref.featureNameArray;
  return _objectSpread$1({}, generateBabelPluginMapSubset({
    babelPluginMap: babelPluginMap,
    featureNameArray: featureNameArray
  }), {}, generateBabelPluginMapForBundle({
    format: format
  }));
};

var generateBabelPluginMapSubset = function generateBabelPluginMapSubset(_ref2) {
  var babelPluginMap = _ref2.babelPluginMap,
      featureNameArray = _ref2.featureNameArray;
  var babelPluginMapSubset = {};
  Object.keys(babelPluginMap).forEach(function (babelPluginName) {
    if (featureNameArray.includes(babelPluginName)) {
      babelPluginMapSubset[babelPluginName] = babelPluginMap[babelPluginName];
    }
  });
  return babelPluginMapSubset;
};

var generateBabelPluginMapForBundle = function generateBabelPluginMapForBundle(_ref3) {
  var format = _ref3.format;
  var bundleBabelPluginMap = {};

  if (format === "commonjs" || format === "global") {
    var importMetaFacadePath = "file://".concat(jsenvBundlingProjectPathname, "/src/babel-plugin-map/import-meta-").concat(format, ".js");
    bundleBabelPluginMap["import-meta-url-named-import"] = createImportMetaUrlNamedImportBabelPlugin({
      importMetaFacadePath: importMetaFacadePath
    });
  }

  return bundleBabelPluginMap;
};

function _await$9(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var fetch = nodeRequire("node-fetch");

function _invoke$1(body, then) {
  var result = body();

  if (result && result.then) {
    return result.then(then);
  }

  return then(result);
}

var AbortController = nodeRequire("abort-controller"); // ideally we should only pass this to the fetch below


function _async$9(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

https.globalAgent.options.rejectUnauthorized = false;
var fetchUsingHttp = _async$9(function (url) {
  var _exit = false;

  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  var cancellationToken = _ref.cancellationToken,
      rest = _objectWithoutProperties(_ref, ["cancellationToken"]);

  return _invoke$1(function () {
    if (cancellationToken) {
      // a cancelled fetch will never resolve, while cancellation api
      // expect to get a rejected promise.
      // createOperation ensure we'll get a promise rejected with a cancelError
      return _await$9(createOperation({
        cancellationToken: cancellationToken,
        start: function start() {
          return fetch(url, _objectSpread$1({
            signal: cancellationTokenToAbortSignal(cancellationToken)
          }, rest));
        }
      }), function (response) {
        _exit = true;
        return normalizeResponse(response);
      });
    }
  }, function (_result) {
    return _exit ? _result : _await$9(fetch(url, rest), normalizeResponse);
  });
});

var normalizeResponse = _async$9(function (response) {
  return _await$9(response.text(), function (text) {
    return {
      url: response.url,
      status: response.status,
      statusText: response.statusText,
      headers: responseToHeaderMap(response),
      body: text
    };
  });
}); // https://github.com/bitinn/node-fetch#request-cancellation-with-abortsignal


var cancellationTokenToAbortSignal = function cancellationTokenToAbortSignal(cancellationToken) {
  var abortController = new AbortController();
  cancellationToken.register(function (reason) {
    abortController.abort(reason);
  });
  return abortController.signal;
};

var responseToHeaderMap = function responseToHeaderMap(response) {
  var headerMap = {};
  response.headers.forEach(function (value, name) {
    headerMap[name] = value;
  });
  return headerMap;
};

var writeSourceMappingURL = function writeSourceMappingURL(source, location) {
  return "".concat(source, "\n", "//#", " sourceMappingURL=").concat(location);
};
var updateSourceMappingURL = function updateSourceMappingURL(source, callback) {
  var sourceMappingUrlRegExp = /\/\/# ?sourceMappingURL=([^\s'"]+)/g;
  var lastSourceMappingUrl;
  var matchSourceMappingUrl;

  while (matchSourceMappingUrl = sourceMappingUrlRegExp.exec(source)) {
    lastSourceMappingUrl = matchSourceMappingUrl;
  }

  if (lastSourceMappingUrl) {
    var index = lastSourceMappingUrl.index;
    var before = source.slice(0, index);
    var after = source.slice(index);
    var mappedAfter = after.replace(sourceMappingUrlRegExp, function (match, firstGroup) {
      return "//#".concat(" sourceMappingURL=", callback(firstGroup));
    });
    return "".concat(before).concat(mappedAfter);
  }

  return source;
};
var readSourceMappingURL = function readSourceMappingURL(source) {
  var sourceMappingURL;
  updateSourceMappingURL(source, function (value) {
    sourceMappingURL = value;
  });
  return sourceMappingURL;
};
var parseSourceMappingURL = function parseSourceMappingURL(source) {
  var sourceMappingURL = readSourceMappingURL(source);
  if (!sourceMappingURL) return null;
  var base64Prefix = "data:application/json;charset=utf-8;base64,";

  if (sourceMappingURL.startsWith(base64Prefix)) {
    var mapBase64Source = sourceMappingURL.slice(base64Prefix.length);
    var sourcemapString = new Buffer(mapBase64Source, "base64").toString("utf8");
    return {
      sourcemapString: sourcemapString
    };
  }

  return {
    sourcemapURL: sourceMappingURL
  };
};
var writeOrUpdateSourceMappingURL = function writeOrUpdateSourceMappingURL(source, location) {
  if (readSourceMappingURL(source)) {
    return updateSourceMappingURL(source, location);
  }

  return writeSourceMappingURL(source, location);
};

function _empty$3() {}

var _require2$a = nodeRequire("@jsenv/core"),
    readProjectImportMap = _require2$a.readProjectImportMap,
    babelHelperMap = _require2$a.babelHelperMap,
    generateBabelHelper = _require2$a.generateBabelHelper,
    cleanCompileCacheFolderIfObsolete = _require2$a.cleanCompileCacheFolderIfObsolete,
    getOrGenerateCompiledFile = _require2$a.getOrGenerateCompiledFile,
    transformJs = _require2$a.transformJs,
    transformResultToCompilationResult = _require2$a.transformResultToCompilationResult,
    compilationResultToTransformResult = _require2$a.compilationResultToTransformResult,
    findAsyncPluginNameInBabelPluginMap = _require2$a.findAsyncPluginNameInBabelPluginMap;

function _awaitIgnored$2(value, direct) {
  if (!direct) {
    return value && value.then ? value.then(_empty$3) : Promise.resolve();
  }
}

var _require3$2 = nodeRequire("terser"),
    minifyCode = _require3$2.minify;

function _invoke$2(body, then) {
  var result = body();

  if (result && result.then) {
    return result.then(then);
  }

  return then(result);
}

function _await$a(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$a(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

function _call$1(body, then, direct) {
  if (direct) {
    return then ? then(body()) : body();
  }

  try {
    var result = Promise.resolve(body());
    return then ? result.then(then) : result;
  } catch (e) {
    return Promise.reject(e);
  }
}

function _catch$1(body, recover) {
  try {
    var result = body();
  } catch (e) {
    return recover(e);
  }

  if (result && result.then) {
    return result.then(void 0, recover);
  }

  return result;
}

var createJsenvRollupPlugin = _async$a(function (_ref) {
  var _imports;

  var cancellationToken = _ref.cancellationToken,
      projectPathname = _ref.projectPathname,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      importAbstractMap = _ref.importAbstractMap,
      importFallbackMap = _ref.importFallbackMap,
      cache = _ref.cache,
      cacheRelativePath = _ref.cacheRelativePath,
      babelPluginMap = _ref.babelPluginMap,
      convertMap = _ref.convertMap,
      featureNameArray = _ref.featureNameArray,
      minify = _ref.minify,
      format = _ref.format,
      _ref$detectAndTransfo = _ref.detectAndTransformIfNeededAsyncInsertedByRollup,
      detectAndTransformIfNeededAsyncInsertedByRollup = _ref$detectAndTransfo === void 0 ? format === "global" : _ref$detectAndTransfo,
      entryPointMap = _ref.entryPointMap,
      logger = _ref.logger;
  var fakeOrigin = "http://example.com";
  var arrayOfHrefToSkipTransform = [];
  var arrayOfAbstractHref = [];

  var getArrayOfAbstractHref = function getArrayOfAbstractHref() {
    return arrayOfAbstractHref;
  };

  var importMapAbstractPath = "/.jsenv/importMap.json";
  var bundleConstantAbstractPath = "/.jsenv/BUNDLE_CONSTANTS.js";
  babelPluginMap = generateBabelPluginMapOption({
    projectPathname: projectPathname,
    format: format,
    babelPluginMap: babelPluginMap,
    featureNameArray: featureNameArray
  });
  var bundleConstantsHref = "file://".concat(jsenvBundlingProjectPathname).concat(bundleConstantAbstractPath);
  var importMapHref = "file://".concat(projectPathname).concat(importMapRelativePath);
  importFallbackMap = _objectSpread$1({}, importFallbackMap, _defineProperty({}, importMapHref, function () {
    return "export default {}";
  }));
  var chunkId = "".concat(Object.keys(entryPointMap)[0], ".js");
  importAbstractMap = _objectSpread$1({}, importAbstractMap, _defineProperty({}, bundleConstantsHref, function () {
    return "export const chunkId = ".concat(JSON.stringify(chunkId));
  }));
  var importMapForBundling = {
    imports: (_imports = {}, _defineProperty(_imports, bundleConstantAbstractPath, bundleConstantsHref), _defineProperty(_imports, importMapAbstractPath, importMapHref), _imports)
  };
  Object.keys(babelHelperMap).forEach(function (babelHelperName) {
    var babelHelperPath = babelHelperMap[babelHelperName];

    if (babelHelperPath.startsWith("@jsenv/core")) ; else {
      importAbstractMap[babelHelperPath] = function () {
        return generateBabelHelper(babelHelperName);
      };
    }
  });
  return _await$a(readProjectImportMap({
    projectPathname: projectPathname,
    jsenvProjectPathname: jsenvBundlingProjectPathname,
    importMapRelativePath: importMapRelativePath,
    logger: logger
  }), function (importMapForProject) {
    return _await$a(generateImportMapForPackage({
      projectPath: jsenvBundlingProjectPath,
      rootProjectPath: pathnameToOperatingSystemPath(projectPathname),
      onWarn: function onWarn(_ref2) {
        var message = _ref2.message;
        return logger.warn(message);
      }
    }), function (_generateImportMapFor) {
      var importMap = normalizeImportMap([_generateImportMapFor, importMapForBundling, importMapForProject, importMapForBundle].reduce(function (previous, current) {
        return composeTwoImportMaps(previous, current);
      }, {}), fakeOrigin);
      var compileCacheFolderRelativePath = "".concat(bundleIntoRelativePath).concat(cacheRelativePath);
      return _invoke$2(function () {
        if (cache) {
          var cacheMeta = {
            featureNameArray: featureNameArray,
            convertMap: convertMap // importMap,
            // importMap influences how the files are resolved
            // but not how they are compiled and cached
            // format,
            // not needed because derived from bundleIntoRelativePath
            // babelPluginMap,
            // not needed because derived from featureNameArray
            // minify,
            // not needed, the bundle itself is not cached
            // and only the bundle is minified

          };
          return _awaitIgnored$2(cleanCompileCacheFolderIfObsolete({
            projectPathname: projectPathname,
            compileCacheFolderRelativePath: compileCacheFolderRelativePath,
            cacheMeta: cacheMeta,
            cleanCallback: function cleanCallback(cacheFolderPath) {
              logger.warn("remove cache folder ".concat(cacheFolderPath));
            }
          }));
        }
      }, function () {
        var jsenvRollupPlugin = {
          name: "jsenv",
          resolveId: function resolveId(specifier, importer) {
            var importerHref;

            if (importer) {
              if (isWindowsPath(importer)) {
                importer = operatingSystemPathToPathname(importer);
              } // 99% of the time importer is an operating system path
              // here we ensure / is resolved against project by forcing an url resolution
              // prefixing with origin


              if (importer.startsWith("".concat(projectPathname, "/"))) {
                importerHref = "".concat(fakeOrigin).concat(pathnameToRelativePath(importer, projectPathname));
              } else if (hrefToScheme(importer)) {
                if (importer.startsWith("file://".concat(projectPathname, "/"))) {
                  importerHref = "".concat(fakeOrigin).concat(pathnameToRelativePath(hrefToPathname(importer), projectPathname));
                } else {
                  // there is already a scheme (http, https, file), keep it
                  // it means there is an absolute import starting with file:// or http:// for instance.
                  importerHref = importer;
                }
              } else {
                throw createImporterOutsideProjectError({
                  importer: importer,
                  projectPathname: projectPathname
                });
              }
            } else {
              importerHref = fakeOrigin;
            }

            var resolvedHref = resolveImport({
              specifier: specifier,
              importer: importerHref,
              importMap: importMap,
              defaultExtension: importDefaultExtension
            });
            var href;

            if (resolvedHref.startsWith("file://")) {
              if (!pathnameIsInside(hrefToPathname(resolvedHref), projectPathname)) {
                throw new Error(createMustBeInsideProjectMessage({
                  href: resolvedHref,
                  specifier: specifier,
                  importer: importer,
                  projectPathname: projectPathname
                }));
              }

              href = resolvedHref;
            } else if (hrefToOrigin(resolvedHref) === fakeOrigin) {
              href = "file://".concat(projectPathname).concat(hrefToPathname(resolvedHref));
            } else {
              // allow external import like import "https://cdn.com/jquery.js"
              href = resolvedHref;
            }

            if (href.startsWith("file://")) {
              // TODO: open an issue rollup side
              // to explain the issue here
              // which is that if id is not an os path
              // sourcemap will be broken
              // (likely because they apply node.js path.resolve)
              // they could either use an other resolution system
              // or provide the ability to change how it's resolved
              // so that the sourcemap.sources does not get broken
              // rollup works with operating system path
              // return os path when possible
              // to ensure we can predict sourcemap.sources returned by rollup
              var filePathame = hrefToPathname(href);
              var filePath = pathnameToOperatingSystemPath(filePathame);

              if (href in importAbstractMap) {
                return filePath;
              } // file presence is optionnal


              if (href in importFallbackMap) {
                return filePath;
              }

              var stats;

              try {
                stats = fs.statSync(filePath);
              } catch (e) {
                if (e.code === "ENOENT") {
                  throw new Error(createFileNotFoundForImportMessage({
                    path: filePath,
                    specifier: specifier,
                    importer: importer
                  }));
                }

                throw e;
              }

              if (!stats.isFile()) {
                throw new Error(createUnexpectedStatsForImportMessage({
                  path: filePath,
                  stats: stats,
                  specifier: specifier,
                  importer: importer
                }));
              }

              return filePath;
            }

            return href;
          },
          // https://rollupjs.org/guide/en#resolvedynamicimport
          // resolveDynamicImport: (specifier, importer) => {
          // },
          load: _async$a(function (rollupId) {
            var href = rollupIdToHref(rollupId);

            if (href in importAbstractMap) {
              var generateSourceForImport = importAbstractMap[href];

              if (typeof generateSourceForImport !== "function") {
                throw new Error("importAbstractMap values must be functions, found ".concat(generateSourceForImport, " for ").concat(href));
              }

              return generateAbstractSourceForImport(href, generateSourceForImport);
            }

            return _await$a(fetchHref(href), function (response) {
              var responseStatus = response.status;

              if (!responseStatusIsOk(responseStatus)) {
                if (responseStatus === 404 && href in importFallbackMap) {
                  return generateAbstractSourceForImport(href, importFallbackMap[href]);
                }

                throw new Error(createUnexpectedResponseStatusMessage({
                  responseStatus: responseStatus,
                  href: href
                }));
              }

              var source = response.body;

              if (href.endsWith(".json")) {
                source = "export default ".concat(source);
              }

              var sourcemapParsingResult = parseSourceMappingURL(source);

              if (!sourcemapParsingResult) {
                return {
                  code: source
                };
              }

              if (sourcemapParsingResult.sourcemapString) {
                return {
                  code: source,
                  map: JSON.parse(sourcemapParsingResult.sourcemapString)
                };
              }

              var resolvedSourceMappingURL = url$1.resolve(href, sourcemapParsingResult.sourcemapURL);
              return _await$a(fetchHref(resolvedSourceMappingURL), function (sourcemapResponse) {
                var sourcemapResponseStatus = sourcemapResponse.status;

                if (!responseStatusIsOk(sourcemapResponse)) {
                  logger.warn(createUnexpectedResponseStatusMessage({
                    responseStatus: sourcemapResponseStatus,
                    href: resolvedSourceMappingURL
                  }));
                  return {
                    code: source
                  };
                }

                return {
                  code: source,
                  map: JSON.parse(sourcemapResponse.body)
                };
              });
            });
          }),
          // resolveImportMeta: () => {}
          transform: _async$a(function (source, rollupId) {
            var sourceHref = rollupIdToHref(rollupId);

            if (arrayOfHrefToSkipTransform.includes(sourceHref)) {
              return null;
            }

            var transform = _async$a(function () {
              return _await$a(transformJs({
                source: source,
                sourceHref: sourceHref,
                projectPathname: projectPathname,
                babelPluginMap: babelPluginMap,
                convertMap: convertMap,
                // false, rollup will take care to transform module into whatever format
                transformModuleIntoSystemFormat: false
              }), function (_ref3) {
                var code = _ref3.code,
                    map = _ref3.map;
                return {
                  code: code,
                  map: map
                };
              });
            });

            if (!cache || !sourceHref.startsWith("file://".concat(projectPathname, "/"))) {
              return transform();
            }

            var sourcePathname = hrefToPathname(sourceHref);
            var sourceRelativePath = pathnameToRelativePath(sourcePathname, projectPathname);
            return _await$a(getOrGenerateCompiledFile({
              projectPathname: projectPathname,
              compileCacheFolderRelativePath: compileCacheFolderRelativePath,
              sourceRelativePath: sourceRelativePath,
              compile: function () {
                return _call$1(transform, function (transformResult) {
                  return transformResultToCompilationResult(transformResult, {
                    source: source,
                    sourceHref: sourceHref,
                    projectPathname: projectPathname
                  });
                });
              }
            }), function (_ref4) {
              var compileResult = _ref4.compileResult;
              return compilationResultToTransformResult(compileResult);
            });
          }),
          renderChunk: function renderChunk(source) {
            if (!minify) return null; // https://github.com/terser-js/terser#minify-options

            var minifyOptions = format === "global" ? {
              toplevel: false
            } : {
              toplevel: true
            };
            var result = minifyCode(source, _objectSpread$1({
              sourceMap: true
            }, minifyOptions));

            if (result.error) {
              throw result.error;
            } else {
              return result;
            }
          },
          writeBundle: _async$a(function (bundle) {
            return _invoke$2(function () {
              if (detectAndTransformIfNeededAsyncInsertedByRollup) {
                return _awaitIgnored$2(transformAsyncInsertedByRollup({
                  projectPathname: projectPathname,
                  bundleIntoRelativePath: bundleIntoRelativePath,
                  babelPluginMap: babelPluginMap,
                  bundle: bundle
                }));
              }
            }, function () {
              Object.keys(bundle).forEach(function (bundleFilename) {
                logger.info("-> ".concat(projectPathname).concat(bundleIntoRelativePath, "/").concat(bundleFilename));
              });
            });
          })
        };

        var markHrefAsAbstract = function markHrefAsAbstract(href) {
          if (!arrayOfAbstractHref.includes(href)) {
            arrayOfAbstractHref.push(href);
          }
        };

        var generateAbstractSourceForImport = _async$a(function (href, generateSource) {
          markHrefAsAbstract(href);
          return _call$1(generateSource, function (returnValue) {
            if (typeof returnValue === "string") {
              return {
                code: returnValue
              };
            }

            var skipTransform = returnValue.skipTransform,
                code = returnValue.code,
                map = returnValue.map;

            if (skipTransform) {
              arrayOfHrefToSkipTransform.push(href);
            }

            return {
              code: code,
              map: map
            };
          });
        });

        var rollupIdToHref = function rollupIdToHref(rollupId) {
          if (isWindowsPath(rollupId)) {
            return "file://".concat(operatingSystemPathToPathname(rollupId));
          }

          if (hrefToScheme(rollupId)) {
            return rollupId;
          }

          return "file://".concat(operatingSystemPathToPathname(rollupId));
        };

        var fetchHref = _async$a(function (href) {
          var _exit = false;
          // this code allow you to have http/https dependency for convenience
          // but maybe we should warn about this.
          // it could also be vastly improved using a basic in memory cache
          return _invoke$2(function () {
            if (href.startsWith("http://")) {
              return _await$a(fetchUsingHttp(href, {
                cancellationToken: cancellationToken
              }), function (response) {
                _exit = true;
                return response;
              });
            }
          }, function (_result) {
            var _exit2 = false;
            if (_exit) return _result;
            return _invoke$2(function () {
              if (href.startsWith("https://")) {
                return _await$a(fetchUsingHttp(href, {
                  cancellationToken: cancellationToken
                }), function (response) {
                  _exit2 = true;
                  return response;
                });
              }
            }, function (_result2) {
              var _exit3 = false;
              if (_exit2) return _result2;
              return _invoke$2(function () {
                if (href.startsWith("file:///")) {
                  return _catch$1(function () {
                    return _await$a(createOperation({
                      cancellationToken: cancellationToken,
                      start: function start() {
                        return fileRead(pathnameToOperatingSystemPath(hrefToPathname(href)));
                      }
                    }), function (code) {
                      _exit3 = true;
                      return {
                        status: 200,
                        body: code
                      };
                    });
                  }, function (e) {
                    if (e.code === "ENOENT") {
                      _exit3 = true;
                      return {
                        status: 404
                      };
                    }

                    _exit3 = true;
                    return {
                      status: 500
                    };
                  });
                }
              }, function (_result3) {
                if (_exit3) return _result3;
                throw new Error("unsupported href: ".concat(href));
              });
            });
          });
        });

        return {
          jsenvRollupPlugin: jsenvRollupPlugin,
          getArrayOfAbstractHref: getArrayOfAbstractHref
        };
      });
    });
  });
});

var responseStatusIsOk = function responseStatusIsOk(responseStatus) {
  return responseStatus >= 200 && responseStatus < 300;
};

var createFileNotFoundForImportMessage = function createFileNotFoundForImportMessage(_ref5) {
  var path = _ref5.path,
      specifier = _ref5.specifier,
      importer = _ref5.importer;
  return "import file not found.\n--- path ---\n".concat(path, "\n--- specifier ---\n").concat(specifier, "\n--- importer ---\n").concat(importer);
};

var createUnexpectedStatsForImportMessage = function createUnexpectedStatsForImportMessage(_ref6) {
  var path = _ref6.path,
      stats = _ref6.stats,
      specifier = _ref6.specifier,
      importer = _ref6.importer;
  return "unexpected import file stats.\n--- path ---\n".concat(path, "\n--- found ---\n").concat(stats.isDirectory(), " ? 'directory' : 'not-a-file'\n--- specifier ---\n").concat(specifier, "\n--- importer ---\n").concat(importer);
};

var createUnexpectedResponseStatusMessage = function createUnexpectedResponseStatusMessage(_ref7) {
  var responseStatus = _ref7.responseStatus,
      href = _ref7.href;
  return "unexpected response status.\n--- response status ---\n".concat(responseStatus, "\n--- href ---\n").concat(href);
};

var createMustBeInsideProjectMessage = function createMustBeInsideProjectMessage(_ref8) {
  var href = _ref8.href,
      specifier = _ref8.specifier,
      importer = _ref8.importer,
      projectPathname = _ref8.projectPathname;
  return "\nsource must be inside project.\n--- href ---\n".concat(href, "\n--- specifier ---\n").concat(specifier, "\n--- importer ---\n").concat(importer, "\n--- project path ---\n").concat(pathnameToOperatingSystemPath(projectPathname));
};

var createImporterOutsideProjectError = function createImporterOutsideProjectError(_ref9) {
  var importer = _ref9.importer,
      projectPathname = _ref9.projectPathname;
  return new Error("importer must be inside project\n  importer: ".concat(importer, "\n  project: ").concat(pathnameToOperatingSystemPath(projectPathname)));
};

var transformAsyncInsertedByRollup = _async$a(function (_ref10) {
  var projectPathname = _ref10.projectPathname,
      bundleIntoRelativePath = _ref10.bundleIntoRelativePath,
      babelPluginMap = _ref10.babelPluginMap,
      bundle = _ref10.bundle;
  var bundleFolderPathname = "".concat(projectPathname).concat(bundleIntoRelativePath);
  var asyncPluginName = findAsyncPluginNameInBabelPluginMap(babelPluginMap);
  if (!asyncPluginName) return; // we have to do this because rollup ads
  // an async wrapper function without transpiling it
  // if your bundle contains a dynamic import

  return _awaitIgnored$2(Promise.all(Object.keys(bundle).map(_async$a(function (bundleFilename) {
    var bundleInfo = bundle[bundleFilename];
    return _await$a(transformJs({
      projectPathname: projectPathname,
      source: bundleInfo.code,
      sourceHref: "file://".concat(operatingSystemPathToPathname(bundleFilename)),
      sourceMap: bundleInfo.map,
      babelPluginMap: _defineProperty({}, asyncPluginName, babelPluginMap[asyncPluginName]),
      transformModuleIntoSystemFormat: false,
      // already done by rollup
      transformGenerator: false // already done

    }), function (_ref11) {
      var code = _ref11.code,
          map = _ref11.map;
      return _awaitIgnored$2(Promise.all([fileWrite(pathnameToOperatingSystemPath("".concat(bundleFolderPathname, "/").concat(bundleFilename)), writeSourceMappingURL(code, "./".concat(bundleFilename, ".map"))), fileWrite(pathnameToOperatingSystemPath("".concat(bundleFolderPathname, "/").concat(bundleFilename, ".map")), JSON.stringify(map))]));
    });
  }))));
});

function _await$b(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var _require2$b = nodeRequire("rollup"),
    rollup = _require2$b.rollup;

function _async$b(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var generateBundleUsingRollup = _async$b(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      rollupParseOptions = _ref.rollupParseOptions,
      rollupGenerateOptions = _ref.rollupGenerateOptions,
      writeOnFileSystem = _ref.writeOnFileSystem;
  return _await$b(createOperation({
    cancellationToken: cancellationToken,
    start: function start() {
      return rollup(_objectSpread$1({
        // about cache here, we should/could reuse previous rollup call
        // to get the cache from the entryPointMap
        // as shown here: https://rollupjs.org/guide/en#cache
        // it could be passed in arguments to this function
        // however parallelism and having different rollup options per
        // call make it a bit complex
        // cache: null
        // https://rollupjs.org/guide/en#experimentaltoplevelawait
        experimentalTopLevelAwait: true,
        // if we want to ignore some warning
        // please use https://rollupjs.org/guide/en#onwarn
        // to be very clear about what we want to ignore
        onwarn: function onwarn(warning, warn) {
          if (warning.code === "THIS_IS_UNDEFINED") return;
          warn(warning);
        }
      }, rollupParseOptions));
    }
  }), function (rollupBundle) {
    return _await$b(createOperation({
      cancellationToken: cancellationToken,
      start: function start() {
        if (writeOnFileSystem) {
          return rollupBundle.write(_objectSpread$1({
            // https://rollupjs.org/guide/en#experimentaltoplevelawait
            experimentalTopLevelAwait: true,
            // we could put prefConst to true by checking 'transform-block-scoping'
            // presence in babelPluginMap
            preferConst: false
          }, rollupGenerateOptions));
        }

        return rollupBundle.generate(_objectSpread$1({
          // https://rollupjs.org/guide/en#experimentaltoplevelawait
          experimentalTopLevelAwait: true,
          // we could put prefConst to true by checking 'transform-block-scoping'
          // presence in babelPluginMap
          preferConst: false
        }, rollupGenerateOptions));
      }
    }));
  });
});

var formatToRollupFormat = function formatToRollupFormat(format) {
  if (format === "global") return "iife";
  if (format === "commonjs") return "cjs";
  if (format === "systemjs") return "system";
  throw new Error("unexpected format, got ".concat(format));
};

function _await$c(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$c(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var bundleWithoutBalancing = _async$c(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      projectPathname = _ref.projectPathname,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      cache = _ref.cache,
      cacheRelativePath = _ref.cacheRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      importAbstractMap = _ref.importAbstractMap,
      importFallbackMap = _ref.importFallbackMap,
      nativeModulePredicate = _ref.nativeModulePredicate,
      entryPointMap = _ref.entryPointMap,
      babelPluginMap = _ref.babelPluginMap,
      convertMap = _ref.convertMap,
      minify = _ref.minify,
      logLevel = _ref.logLevel,
      format = _ref.format,
      formatOutputOptions = _ref.formatOutputOptions,
      writeOnFileSystem = _ref.writeOnFileSystem;
  var logger = createLogger({
    logLevel: logLevel
  });
  var dir = pathnameToOperatingSystemPath("".concat(projectPathname).concat(bundleIntoRelativePath));
  return _await$c(createJsenvRollupPlugin({
    cancellationToken: cancellationToken,
    projectPathname: projectPathname,
    bundleIntoRelativePath: bundleIntoRelativePath,
    cache: cache,
    cacheRelativePath: cacheRelativePath,
    entryPointMap: entryPointMap,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    importAbstractMap: importAbstractMap,
    importFallbackMap: importFallbackMap,
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    featureNameArray: Object.keys(babelPluginMap),
    minify: minify,
    format: format,
    logger: logger
  }), function (_ref2) {
    var jsenvRollupPlugin = _ref2.jsenvRollupPlugin,
        getArrayOfAbstractHref = _ref2.getArrayOfAbstractHref;
    logger.trace("\nbundle entry points without balancing.\nformat: ".concat(format, "\nentry point names: ").concat(Object.keys(entryPointMap), "\ndir: ").concat(dir, "\nminify: ").concat(minify, "\n"));
    return _await$c(generateBundleUsingRollup({
      cancellationToken: cancellationToken,
      writeOnFileSystem: writeOnFileSystem,
      rollupParseOptions: {
        input: entryPointMap,
        plugins: [jsenvRollupPlugin],
        external: function external(id) {
          return nativeModulePredicate(id);
        }
      },
      rollupGenerateOptions: _objectSpread$1({
        // https://rollupjs.org/guide/en#output-dir
        dir: dir,
        // https://rollupjs.org/guide/en#output-format
        format: formatToRollupFormat(format),
        // entryFileNames: `./[name].js`,
        // https://rollupjs.org/guide/en#output-sourcemap
        sourcemap: true,
        // we could exclude them
        // but it's better to put them directly
        // in case source files are not reachable
        // for whatever reason
        sourcemapExcludeSources: false
      }, formatOutputOptions)
    }), function (rollupBundle) {
      return {
        rollupBundle: rollupBundle,
        arrayOfAbstractHref: getArrayOfAbstractHref()
      };
    });
  });
});

function _await$d(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$d(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var bundleWithBalancing = _async$d(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      projectPathname = _ref.projectPathname,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      cache = _ref.cache,
      cacheRelativePath = _ref.cacheRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      importAbstractMap = _ref.importAbstractMap,
      importFallbackMap = _ref.importFallbackMap,
      nativeModulePredicate = _ref.nativeModulePredicate,
      entryPointMap = _ref.entryPointMap,
      babelPluginMap = _ref.babelPluginMap,
      convertMap = _ref.convertMap,
      minify = _ref.minify,
      logLevel = _ref.logLevel,
      format = _ref.format,
      formatOutputOptions = _ref.formatOutputOptions,
      groupMap = _ref.groupMap,
      compileId = _ref.compileId,
      writeOnFileSystem = _ref.writeOnFileSystem;
  var logger = createLogger({
    logLevel: logLevel
  });
  var dir = pathnameToOperatingSystemPath("".concat(projectPathname).concat(bundleIntoRelativePath, "/").concat(compileId));
  return _await$d(createJsenvRollupPlugin({
    cancellationToken: cancellationToken,
    projectPathname: projectPathname,
    bundleIntoRelativePath: "".concat(bundleIntoRelativePath, "/").concat(compileId),
    cache: cache,
    cacheRelativePath: cacheRelativePath,
    entryPointMap: entryPointMap,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    importAbstractMap: importAbstractMap,
    importFallbackMap: importFallbackMap,
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    featureNameArray: groupMap[compileId].incompatibleNameArray,
    minify: minify,
    format: format,
    logger: logger
  }), function (_ref2) {
    var jsenvRollupPlugin = _ref2.jsenvRollupPlugin,
        getArrayOfAbstractHref = _ref2.getArrayOfAbstractHref;
    logger.trace("\n  bundle entry points with balancing.\n  format: ".concat(format, "\n  compileId: ").concat(compileId, "\n  entryPointArray: ").concat(Object.keys(entryPointMap), "\n  dir: ").concat(dir, "\n  minify: ").concat(minify, "\n  "));
    return _await$d(generateBundleUsingRollup({
      cancellationToken: cancellationToken,
      writeOnFileSystem: writeOnFileSystem,
      rollupParseOptions: {
        input: entryPointMap,
        plugins: [jsenvRollupPlugin],
        external: function external(id) {
          return nativeModulePredicate(id);
        }
      },
      rollupGenerateOptions: _objectSpread$1({
        dir: dir,
        format: formatToRollupFormat(format),
        sourcemap: true,
        sourceMapExcludeSources: true
      }, formatOutputOptions)
    }), function (rollupBundle) {
      return {
        rollupBundle: rollupBundle,
        arrayOfAbstractHref: getArrayOfAbstractHref()
      };
    });
  });
});

function _await$e(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$e(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var bundleBalancer = _async$e(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      projectPathname = _ref.projectPathname,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      cache = _ref.cache,
      cacheRelativePath = _ref.cacheRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      importAbstractMap = _ref.importAbstractMap,
      importFallbackMap = _ref.importFallbackMap,
      nativeModulePredicate = _ref.nativeModulePredicate,
      entryPointMap = _ref.entryPointMap,
      babelPluginMap = _ref.babelPluginMap,
      convertMap = _ref.convertMap,
      minify = _ref.minify,
      logLevel = _ref.logLevel,
      format = _ref.format,
      balancerDataAbstractPath = _ref.balancerDataAbstractPath,
      groupMap = _ref.groupMap,
      writeOnFileSystem = _ref.writeOnFileSystem;
  var logger = createLogger({
    logLevel: logLevel
  });
  var entryPointName = Object.keys(entryPointMap)[0];
  var dir = pathnameToOperatingSystemPath("".concat(projectPathname).concat(bundleIntoRelativePath));
  var balancerDataHref = "file://".concat(jsenvBundlingProjectPathname).concat(balancerDataAbstractPath);
  return _await$e(createJsenvRollupPlugin({
    cancellationToken: cancellationToken,
    projectPathname: projectPathname,
    bundleIntoRelativePath: bundleIntoRelativePath,
    cache: cache,
    cacheRelativePath: cacheRelativePath,
    entryPointMap: entryPointMap,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: composeTwoImportMaps(importMapForBundle || {}, {
      imports: _defineProperty({}, balancerDataAbstractPath, balancerDataHref)
    }),
    importAbstractMap: _objectSpread$1({}, importAbstractMap, _defineProperty({}, balancerDataHref, function () {
      return "export const entryPointName = ".concat(JSON.stringify(entryPointName), "\n  export const groupMap = ").concat(JSON.stringify(groupMap));
    })),
    importFallbackMap: importFallbackMap,
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    featureNameArray: groupMap.otherwise.incompatibleNameArray,
    minify: minify,
    format: format,
    logger: logger
  }), function (_ref2) {
    var jsenvRollupPlugin = _ref2.jsenvRollupPlugin,
        getArrayOfAbstractHref = _ref2.getArrayOfAbstractHref;
    logger.trace("\n  bundle balancer file.\n  format: ".concat(format, "\n  entryPointName: ").concat(entryPointName, "\n  file: ").concat(dir, "/").concat(entryPointName, ".js\n  minify: ").concat(minify, "\n  "));
    return _await$e(generateBundleUsingRollup({
      cancellationToken: cancellationToken,
      writeOnFileSystem: writeOnFileSystem,
      rollupParseOptions: {
        input: entryPointMap,
        plugins: [jsenvRollupPlugin],
        external: function external(id) {
          return nativeModulePredicate(id);
        }
      },
      rollupGenerateOptions: {
        dir: dir,
        format: "iife",
        sourcemap: true,
        sourcemapExcludeSources: true
      }
    }), function (rollupBundle) {
      return {
        rollupBundle: rollupBundle,
        arrayOfAbstractHref: getArrayOfAbstractHref()
      };
    });
  });
});

var rimraf$1 = nodeRequire("rimraf");

var removeFolder = function removeFolder(foldername) {
  return new Promise(function (resolve, reject) {
    return rimraf$1(foldername, function (error) {
      if (error) reject(error);else resolve();
    });
  });
};

var _require2$c = nodeRequire("@jsenv/babel-plugin-map"),
    jsenvBabelPluginMap = _require2$c.jsenvBabelPluginMap;

var DEFAULT_IMPORT_MAP_RELATIVE_PATH = "/importMap.json";
var DEFAULT_ENTRY_POINT_MAP = {
  main: "index.js"
}; // https://github.com/browserify/resolve/blob/a09a2e7f16273970be4639313c83b913daea15d7/lib/core.json#L1
// https://nodejs.org/api/modules.html#modules_module_builtinmodules
// https://stackoverflow.com/a/35825896
// https://github.com/browserify/resolve/blob/master/lib/core.json#L1

var NATIVE_NODE_MODULE_SPECIFIER_ARRAY = ["assert", "async_hooks", "buffer_ieee754", "buffer", "child_process", "cluster", "console", "constants", "crypto", "_debugger", "dgram", "dns", "domain", "events", "freelist", "fs", "fs/promises", "_http_agent", "_http_client", "_http_common", "_http_incoming", "_http_outgoing", "_http_server", "http", "http2", "https", "inspector", "_linklist", "module", "net", "node-inspect/lib/_inspect", "node-inspect/lib/internal/inspect_client", "node-inspect/lib/internal/inspect_repl", "os", "path", "perf_hooks", "process", "punycode", "querystring", "readline", "repl", "smalloc", "_stream_duplex", "_stream_transform", "_stream_wrap", "_stream_passthrough", "_stream_readable", "_stream_writable", "stream", "string_decoder", "sys", "timers", "_tls_common", "_tls_legacy", "_tls_wrap", "tls", "trace_events", "tty", "url", "util", "v8/tools/arguments", "v8/tools/codemap", "v8/tools/consarray", "v8/tools/csvparser", "v8/tools/logreader", "v8/tools/profile_view", "v8/tools/splaytree", "v8", "vm", "worker_threads", "zlib", // global is special
"global"];
var DEFAULT_NATIVE_MODULE_PREDICATE = function DEFAULT_NATIVE_MODULE_PREDICATE(id) {
  if (id === "global") return false;
  if (NATIVE_NODE_MODULE_SPECIFIER_ARRAY.includes(id)) return true;
  return false;
};
var DEFAULT_BABEL_PLUGIN_MAP = jsenvBabelPluginMap;
var DEFAULT_PLATFORM_SCORE_MAP = _objectSpread$1({}, browserScoreMap, {
  node: nodeVersionScoreMap
});

function _empty$4() {}

function _awaitIgnored$3(value, direct) {
  if (!direct) {
    return value && value.then ? value.then(_empty$4) : Promise.resolve();
  }
}

function _await$f(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _invoke$3(body, then) {
  var result = body();

  if (result && result.then) {
    return result.then(then);
  }

  return then(result);
}

function _async$f(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var generateBundle = function generateBundle(_ref) {
  var projectPath = _ref.projectPath,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      _ref$cleanBundleInto = _ref.cleanBundleInto,
      cleanBundleInto = _ref$cleanBundleInto === void 0 ? false : _ref$cleanBundleInto,
      _ref$cache = _ref.cache,
      cache = _ref$cache === void 0 ? false : _ref$cache,
      _ref$cacheRelativePat = _ref.cacheRelativePath,
      cacheRelativePath = _ref$cacheRelativePat === void 0 ? "/.cache" : _ref$cacheRelativePat,
      importDefaultExtension = _ref.importDefaultExtension,
      _ref$importMapRelativ = _ref.importMapRelativePath,
      importMapRelativePath = _ref$importMapRelativ === void 0 ? DEFAULT_IMPORT_MAP_RELATIVE_PATH : _ref$importMapRelativ,
      _ref$importMapForBund = _ref.importMapForBundle,
      importMapForBundle = _ref$importMapForBund === void 0 ? {} : _ref$importMapForBund,
      _ref$importAbstractMa = _ref.importAbstractMap,
      importAbstractMap = _ref$importAbstractMa === void 0 ? {} : _ref$importAbstractMa,
      _ref$importFallbackMa = _ref.importFallbackMap,
      importFallbackMap = _ref$importFallbackMa === void 0 ? {} : _ref$importFallbackMa,
      _ref$nativeModulePred = _ref.nativeModulePredicate,
      nativeModulePredicate = _ref$nativeModulePred === void 0 ? DEFAULT_NATIVE_MODULE_PREDICATE : _ref$nativeModulePred,
      _ref$entryPointMap = _ref.entryPointMap,
      entryPointMap = _ref$entryPointMap === void 0 ? DEFAULT_ENTRY_POINT_MAP : _ref$entryPointMap,
      _ref$babelPluginMap = _ref.babelPluginMap,
      babelPluginMap = _ref$babelPluginMap === void 0 ? DEFAULT_BABEL_PLUGIN_MAP : _ref$babelPluginMap,
      convertMap = _ref.convertMap,
      logLevel = _ref.logLevel,
      _ref$minify = _ref.minify,
      minify = _ref$minify === void 0 ? false : _ref$minify,
      _ref$writeOnFileSyste = _ref.writeOnFileSystem,
      writeOnFileSystem = _ref$writeOnFileSyste === void 0 ? true : _ref$writeOnFileSyste,
      _ref$throwUnhandled = _ref.throwUnhandled,
      throwUnhandled = _ref$throwUnhandled === void 0 ? true : _ref$throwUnhandled,
      format = _ref.format,
      _ref$formatOutputOpti = _ref.formatOutputOptions,
      formatOutputOptions = _ref$formatOutputOpti === void 0 ? {} : _ref$formatOutputOpti,
      _ref$compileGroupCoun = _ref.compileGroupCount,
      compileGroupCount = _ref$compileGroupCoun === void 0 ? 1 : _ref$compileGroupCoun,
      platformAlwaysInsidePlatformScoreMap = _ref.platformAlwaysInsidePlatformScoreMap,
      balancerTemplateRelativePath = _ref.balancerTemplateRelativePath,
      defaultBalancerTemplateHref = _ref.defaultBalancerTemplateHref,
      balancerDataAbstractPath = _ref.balancerDataAbstractPath,
      _ref$platformScoreMap = _ref.platformScoreMap,
      platformScoreMap = _ref$platformScoreMap === void 0 ? DEFAULT_PLATFORM_SCORE_MAP : _ref$platformScoreMap;
  var promise = catchAsyncFunctionCancellation(_async$f(function () {
    if (typeof projectPath !== "string") throw new TypeError("projectPath must be a string, got ".concat(projectPath));
    if (typeof bundleIntoRelativePath !== "string") throw new TypeError("bundleIntoRelativePath must be a string, got ".concat(bundleIntoRelativePath));
    if (_typeof(entryPointMap) !== "object") throw new TypeError("entryPointMap must be an object, got ".concat(entryPointMap));
    if (typeof compileGroupCount !== "number") throw new TypeError("compileGroupCount must be a number, got ".concat(compileGroupCount));
    if (compileGroupCount < 1) throw new Error("compileGroupCount must be >= 1, got ".concat(compileGroupCount));
    var cancellationToken = createProcessInterruptionCancellationToken();
    var projectPathname = operatingSystemPathToPathname(projectPath);
    return _await$f(assertFolder(projectPathname), function () {
      return _invoke$3(function () {
        if (cleanBundleInto) {
          return _awaitIgnored$3(removeFolder(pathnameToOperatingSystemPath("".concat(projectPathname).concat(bundleIntoRelativePath))));
        }
      }, function () {
        if (compileGroupCount === 1) {
          return bundleWithoutBalancing({
            cancellationToken: cancellationToken,
            projectPathname: projectPathname,
            bundleIntoRelativePath: bundleIntoRelativePath,
            cache: cache,
            cacheRelativePath: cacheRelativePath,
            importDefaultExtension: importDefaultExtension,
            importMapRelativePath: importMapRelativePath,
            importMapForBundle: importMapForBundle,
            importAbstractMap: importAbstractMap,
            importFallbackMap: importFallbackMap,
            nativeModulePredicate: nativeModulePredicate,
            entryPointMap: entryPointMap,
            babelPluginMap: babelPluginMap,
            convertMap: convertMap,
            minify: minify,
            logLevel: logLevel,
            format: format,
            formatOutputOptions: formatOutputOptions,
            writeOnFileSystem: writeOnFileSystem
          });
        }

        if (typeof balancerTemplateRelativePath === "undefined") {
          if (!defaultBalancerTemplateHref) {
            throw createFormatIncompatibleWithBalancingError({
              format: format
            });
          }

          balancerTemplateRelativePath = jsenvBundlingRelativePathInception({
            jsenvBundlingRelativePath: defaultBalancerTemplateHref,
            projectPathname: projectPathname
          });
        }

        var balancerTemplatePathname = "".concat(projectPathname).concat(balancerTemplateRelativePath);
        var balancerTemplateHref = "file://".concat(balancerTemplatePathname);
        return _await$f(assertFile(pathnameToOperatingSystemPath(balancerTemplatePathname)), function () {
          var groupMap = generateGroupMap({
            babelPluginMap: babelPluginMap,
            platformScoreMap: platformScoreMap,
            groupCount: compileGroupCount,
            platformAlwaysInsidePlatformScoreMap: platformAlwaysInsidePlatformScoreMap
          });
          return _await$f(Promise.all([generateEntryPointsFolders({
            cancellationToken: cancellationToken,
            projectPathname: projectPathname,
            bundleIntoRelativePath: bundleIntoRelativePath,
            cache: cache,
            cacheRelativePath: cacheRelativePath,
            importDefaultExtension: importDefaultExtension,
            importMapRelativePath: importMapRelativePath,
            importMapForBundle: importMapForBundle,
            importAbstractMap: importAbstractMap,
            importFallbackMap: importFallbackMap,
            nativeModulePredicate: nativeModulePredicate,
            entryPointMap: entryPointMap,
            babelPluginMap: babelPluginMap,
            convertMap: convertMap,
            minify: minify,
            logLevel: logLevel,
            writeOnFileSystem: writeOnFileSystem,
            format: format,
            formatOutputOptions: formatOutputOptions,
            groupMap: groupMap
          }), generateEntryPointsBalancerFiles({
            cancellationToken: cancellationToken,
            projectPathname: projectPathname,
            bundleIntoRelativePath: bundleIntoRelativePath,
            cache: cache,
            cacheRelativePath: cacheRelativePath,
            importDefaultExtension: importDefaultExtension,
            importMapRelativePath: importMapRelativePath,
            importMapForBundle: importMapForBundle,
            importAbstractMap: importAbstractMap,
            importFallbackMap: importFallbackMap,
            nativeModulePredicate: nativeModulePredicate,
            entryPointMap: entryPointMap,
            babelPluginMap: babelPluginMap,
            convertMap: convertMap,
            minify: minify,
            logLevel: logLevel,
            writeOnFileSystem: writeOnFileSystem,
            format: format,
            balancerTemplateHref: balancerTemplateHref,
            balancerDataAbstractPath: balancerDataAbstractPath,
            groupMap: groupMap
          })]));
        });
      });
    });
  }));
  if (!throwUnhandled) return promise;
  return promise.catch(function (e) {
    setTimeout(function () {
      throw e;
    });
  });
};

var generateEntryPointsFolders = _async$f(function (_ref2) {
  var cancellationToken = _ref2.cancellationToken,
      projectPathname = _ref2.projectPathname,
      bundleIntoRelativePath = _ref2.bundleIntoRelativePath,
      cache = _ref2.cache,
      cacheRelativePath = _ref2.cacheRelativePath,
      importDefaultExtension = _ref2.importDefaultExtension,
      importMapRelativePath = _ref2.importMapRelativePath,
      importMapForBundle = _ref2.importMapForBundle,
      importAbstractMap = _ref2.importAbstractMap,
      importFallbackMap = _ref2.importFallbackMap,
      nativeModulePredicate = _ref2.nativeModulePredicate,
      entryPointMap = _ref2.entryPointMap,
      babelPluginMap = _ref2.babelPluginMap,
      convertMap = _ref2.convertMap,
      minify = _ref2.minify,
      logLevel = _ref2.logLevel,
      writeOnFileSystem = _ref2.writeOnFileSystem,
      format = _ref2.format,
      formatOutputOptions = _ref2.formatOutputOptions,
      groupMap = _ref2.groupMap;
  return Promise.all(Object.keys(groupMap).map(_async$f(function (compileId) {
    return bundleWithBalancing({
      cancellationToken: cancellationToken,
      projectPathname: projectPathname,
      bundleIntoRelativePath: bundleIntoRelativePath,
      cache: cache,
      cacheRelativePath: cacheRelativePath,
      importDefaultExtension: importDefaultExtension,
      importMapRelativePath: importMapRelativePath,
      importMapForBundle: importMapForBundle,
      importAbstractMap: importAbstractMap,
      importFallbackMap: importFallbackMap,
      nativeModulePredicate: nativeModulePredicate,
      entryPointMap: entryPointMap,
      babelPluginMap: babelPluginMap,
      convertMap: convertMap,
      minify: minify,
      logLevel: logLevel,
      format: format,
      formatOutputOptions: formatOutputOptions,
      groupMap: groupMap,
      compileId: compileId,
      writeOnFileSystem: writeOnFileSystem
    });
  })));
});

var generateEntryPointsBalancerFiles = function generateEntryPointsBalancerFiles(_ref3) {
  var cancellationToken = _ref3.cancellationToken,
      projectPathname = _ref3.projectPathname,
      bundleIntoRelativePath = _ref3.bundleIntoRelativePath,
      cache = _ref3.cache,
      cacheRelativePath = _ref3.cacheRelativePath,
      importDefaultExtension = _ref3.importDefaultExtension,
      importMapRelativePath = _ref3.importMapRelativePath,
      importMapForBundle = _ref3.importMapForBundle,
      importAbstractMap = _ref3.importAbstractMap,
      importFallbackMap = _ref3.importFallbackMap,
      nativeModulePredicate = _ref3.nativeModulePredicate,
      entryPointMap = _ref3.entryPointMap,
      babelPluginMap = _ref3.babelPluginMap,
      convertMap = _ref3.convertMap,
      minify = _ref3.minify,
      logLevel = _ref3.logLevel,
      writeOnFileSystem = _ref3.writeOnFileSystem,
      format = _ref3.format,
      balancerTemplateHref = _ref3.balancerTemplateHref,
      balancerDataAbstractPath = _ref3.balancerDataAbstractPath,
      groupMap = _ref3.groupMap;
  return Promise.all(Object.keys(entryPointMap).map(_async$f(function (entryPointName) {
    return bundleBalancer({
      cancellationToken: cancellationToken,
      projectPathname: projectPathname,
      bundleIntoRelativePath: bundleIntoRelativePath,
      cache: cache,
      cacheRelativePath: cacheRelativePath,
      importDefaultExtension: importDefaultExtension,
      importMapRelativePath: importMapRelativePath,
      importMapForBundle: importMapForBundle,
      importAbstractMap: importAbstractMap,
      importFallbackMap: importFallbackMap,
      nativeModulePredicate: nativeModulePredicate,
      entryPointMap: _defineProperty({}, entryPointName, balancerTemplateHref),
      babelPluginMap: babelPluginMap,
      convertMap: convertMap,
      minify: minify,
      logLevel: logLevel,
      format: format,
      balancerDataAbstractPath: balancerDataAbstractPath,
      groupMap: groupMap,
      writeOnFileSystem: writeOnFileSystem
    });
  })));
};

var createFormatIncompatibleWithBalancingError = function createFormatIncompatibleWithBalancingError(_ref4) {
  var format = _ref4.format;
  return new Error("format not compatible with balancing.\nformat: ".concat(format));
};

var DEFAULT_BUNDLE_INTO_RELATIVE_PATH = "/dist/global";

function _async$g(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var generateGlobalBundle = _async$g(function (_ref) {
  var projectPath = _ref.projectPath,
      _ref$bundleIntoRelati = _ref.bundleIntoRelativePath,
      bundleIntoRelativePath = _ref$bundleIntoRelati === void 0 ? DEFAULT_BUNDLE_INTO_RELATIVE_PATH : _ref$bundleIntoRelati,
      cleanBundleInto = _ref.cleanBundleInto,
      cache = _ref.cache,
      cacheRelativePath = _ref.cacheRelativePath,
      globalName = _ref.globalName,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      importAbstractMap = _ref.importAbstractMap,
      importFallbackMap = _ref.importFallbackMap,
      entryPointMap = _ref.entryPointMap,
      babelPluginMap = _ref.babelPluginMap,
      convertMap = _ref.convertMap,
      logLevel = _ref.logLevel,
      minify = _ref.minify,
      throwUnhandled = _ref.throwUnhandled,
      writeOnFileSystem = _ref.writeOnFileSystem,
      platformScoreMap = _ref.platformScoreMap,
      platformAlwaysInsidePlatformScoreMap = _ref.platformAlwaysInsidePlatformScoreMap;
  return generateBundle({
    format: "global",
    formatOutputOptions: globalName ? {
      name: globalName
    } : {},
    projectPath: projectPath,
    bundleIntoRelativePath: bundleIntoRelativePath,
    cleanBundleInto: cleanBundleInto,
    cache: cache,
    cacheRelativePath: cacheRelativePath,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    importAbstractMap: importAbstractMap,
    importFallbackMap: importFallbackMap,
    entryPointMap: entryPointMap,
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    logLevel: logLevel,
    minify: minify,
    throwUnhandled: throwUnhandled,
    writeOnFileSystem: writeOnFileSystem,
    compileGroupCount: 1,
    platformScoreMap: platformScoreMap,
    platformAlwaysInsidePlatformScoreMap: platformAlwaysInsidePlatformScoreMap
  });
});

var DEFAULT_BUNDLE_INTO_RELATIVE_PATH$1 = "/dist/commonjs";

function _async$h(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var generateCommonJsBundle = _async$h(function (_ref) {
  var projectPath = _ref.projectPath,
      _ref$bundleIntoRelati = _ref.bundleIntoRelativePath,
      bundleIntoRelativePath = _ref$bundleIntoRelati === void 0 ? DEFAULT_BUNDLE_INTO_RELATIVE_PATH$1 : _ref$bundleIntoRelati,
      cleanBundleInto = _ref.cleanBundleInto,
      cache = _ref.cache,
      cacheRelativePath = _ref.cacheRelativePath,
      balancerTemplateRelativePath = _ref.balancerTemplateRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      importAbstractMap = _ref.importAbstractMap,
      importFallbackMap = _ref.importFallbackMap,
      entryPointMap = _ref.entryPointMap,
      babelPluginMap = _ref.babelPluginMap,
      convertMap = _ref.convertMap,
      logLevel = _ref.logLevel,
      minify = _ref.minify,
      throwUnhandled = _ref.throwUnhandled,
      writeOnFileSystem = _ref.writeOnFileSystem,
      compileGroupCount = _ref.compileGroupCount,
      platformScoreMap = _ref.platformScoreMap,
      platformAlwaysInsidePlatformScoreMap = _ref.platformAlwaysInsidePlatformScoreMap;
  return generateBundle({
    format: "commonjs",
    balancerTemplateRelativePath: balancerTemplateRelativePath,
    defaultBalancerTemplateHref: "file://".concat(jsenvBundlingProjectPathname, "/src/bundle-commonjs/commonjs-balancer-template.js"),
    balancerDataAbstractPath: "/.jsenv/commonjs-balancer-data.js",
    projectPath: projectPath,
    bundleIntoRelativePath: bundleIntoRelativePath,
    cache: cache,
    cacheRelativePath: cacheRelativePath,
    cleanBundleInto: cleanBundleInto,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    importAbstractMap: importAbstractMap,
    importFallbackMap: importFallbackMap,
    entryPointMap: entryPointMap,
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    logLevel: logLevel,
    minify: minify,
    throwUnhandled: throwUnhandled,
    writeOnFileSystem: writeOnFileSystem,
    compileGroupCount: compileGroupCount,
    platformScoreMap: platformScoreMap,
    platformAlwaysInsidePlatformScoreMap: platformAlwaysInsidePlatformScoreMap
  });
});

var DEFAULT_BUNDLE_INTO_RELATIVE_PATH$2 = "/dist/systemjs";

function _async$i(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var generateSystemJsBundle = _async$i(function (_ref) {
  var projectPath = _ref.projectPath,
      _ref$bundleIntoRelati = _ref.bundleIntoRelativePath,
      bundleIntoRelativePath = _ref$bundleIntoRelati === void 0 ? DEFAULT_BUNDLE_INTO_RELATIVE_PATH$2 : _ref$bundleIntoRelati,
      cleanBundleInto = _ref.cleanBundleInto,
      cache = _ref.cache,
      cacheRelativePath = _ref.cacheRelativePath,
      balancerTemplateRelativePath = _ref.balancerTemplateRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      importAbstractMap = _ref.importAbstractMap,
      importFallbackMap = _ref.importFallbackMap,
      entryPointMap = _ref.entryPointMap,
      babelPluginMap = _ref.babelPluginMap,
      convertMap = _ref.convertMap,
      logLevel = _ref.logLevel,
      minify = _ref.minify,
      throwUnhandled = _ref.throwUnhandled,
      writeOnFileSystem = _ref.writeOnFileSystem,
      compileGroupCount = _ref.compileGroupCount,
      platformScoreMap = _ref.platformScoreMap,
      platformAlwaysInsidePlatformScoreMap = _ref.platformAlwaysInsidePlatformScoreMap;
  return generateBundle({
    format: "systemjs",
    balancerTemplateRelativePath: balancerTemplateRelativePath,
    defaultBalancerTemplateHref: "file://".concat(jsenvBundlingProjectPathname, "/src/bundle-systemjs/systemjs-balancer-template.js"),
    balancerDataAbstractPath: "/.jsenv/systemjs-balancer-data.js",
    projectPath: projectPath,
    bundleIntoRelativePath: bundleIntoRelativePath,
    cleanBundleInto: cleanBundleInto,
    cache: cache,
    cacheRelativePath: cacheRelativePath,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    importAbstractMap: importAbstractMap,
    importFallbackMap: importFallbackMap,
    entryPointMap: entryPointMap,
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    logLevel: logLevel,
    minify: minify,
    throwUnhandled: throwUnhandled,
    writeOnFileSystem: writeOnFileSystem,
    compileGroupCount: compileGroupCount,
    platformScoreMap: platformScoreMap,
    platformAlwaysInsidePlatformScoreMap: platformAlwaysInsidePlatformScoreMap
  });
});

var bundleToCompilationResult = function bundleToCompilationResult(_ref, _ref2) {
  var rollupBundle = _ref.rollupBundle,
      arrayOfAbstractHref = _ref.arrayOfAbstractHref;
  var projectPathname = _ref2.projectPathname,
      entryRelativePath = _ref2.entryRelativePath,
      sourcemapAssetPath = _ref2.sourcemapAssetPath,
      _ref2$sourcemapPath = _ref2.sourcemapPath,
      sourcemapPath = _ref2$sourcemapPath === void 0 ? sourcemapAssetPath : _ref2$sourcemapPath;
  var sources = [];
  var sourcesContent = [];
  var assets = [];
  var assetsContent = [];
  var output = rollupBundle.output;
  var main = output[0];
  var mainRollupSourcemap = main.map;
  var mainDependencyMap = rollupSourcemapToDependencyMap({
    rollupSourcemap: mainRollupSourcemap,
    projectPathname: projectPathname,
    entryRelativePath: entryRelativePath,
    arrayOfAbstractHref: arrayOfAbstractHref
  });

  var addDependencyMap = function addDependencyMap(dependencyMap) {
    Object.keys(dependencyMap).forEach(function (relativePath) {
      if (arrayOfAbstractHref.includes("file://".concat(projectPathname).concat(relativePath))) return;
      if (sources.includes(relativePath)) return;
      sources.push(relativePath);
      sourcesContent.push(dependencyMap[relativePath]);
    });
  }; // main file


  var mainSourceContent = writeOrUpdateSourceMappingURL(main.code, sourcemapPath); // main sourcemap

  assets.push(sourcemapAssetPath.slice(2));

  var mainSourcemap = _objectSpread$1({}, mainRollupSourcemap, {}, dependencyMapToSourcemapSubset(mainDependencyMap));

  assetsContent.push(JSON.stringify(mainSourcemap, null, "  ")); // main dependencies

  addDependencyMap(mainDependencyMap);
  output.slice(1).forEach(function (chunk) {
    var chunkRollupSourcemap = chunk.map;
    var chunkDependencyMap = rollupSourcemapToDependencyMap({
      rollupSourcemap: chunkRollupSourcemap,
      projectPathname: projectPathname,
      entryRelativePath: entryRelativePath,
      arrayOfAbstractHref: arrayOfAbstractHref
    }); // chunk file

    assets.push(chunk.fileName);
    var chunkSourceContent = writeOrUpdateSourceMappingURL(chunk.code, "./".concat(chunk.fileName, ".map"));
    assetsContent.push(chunkSourceContent); // chunk sourcemap

    assets.push("".concat(chunk.fileName, ".map"));

    var chunkSourcemap = _objectSpread$1({}, chunkRollupSourcemap, {}, dependencyMapToSourcemapSubset(chunkDependencyMap));

    assetsContent.push(JSON.stringify(chunkSourcemap, null, "  ")); // chunk dependencies

    addDependencyMap(chunkDependencyMap);
  });
  return {
    contentType: "application/javascript",
    compiledSource: mainSourceContent,
    sources: sources,
    sourcesContent: sourcesContent,
    assets: assets,
    assetsContent: assetsContent
  };
};

var dependencyMapToSourcemapSubset = function dependencyMapToSourcemapSubset(dependencyMap) {
  var sources = Object.keys(dependencyMap);
  var sourcesContent = sources.map(function (source) {
    // for sourcemap the source content of a json file is the js
    // transformation of that json
    if (source.endsWith(".json")) return "export default ".concat(dependencyMap[source]);
    return dependencyMap[source];
  });
  return {
    sources: sources,
    sourcesContent: sourcesContent
  };
};

var rollupSourcemapToDependencyMap = function rollupSourcemapToDependencyMap(_ref3) {
  var rollupSourcemap = _ref3.rollupSourcemap,
      projectPathname = _ref3.projectPathname,
      entryRelativePath = _ref3.entryRelativePath,
      arrayOfAbstractHref = _ref3.arrayOfAbstractHref;
  var dependencyMap = {};
  rollupSourcemap.sources.forEach(function (source, index) {
    if (hrefToScheme(source)) {
      // source is absolute
      return;
    } // source is relative


    var sourcePath = path.resolve(path.dirname(pathnameToOperatingSystemPath("".concat(projectPathname).concat(entryRelativePath))), source);
    var sourcePathname = operatingSystemPathToPathname(sourcePath);

    if (!pathnameIsInside(sourcePathname, projectPathname)) {
      throw createSourceOutsideProjectError({
        sourcePath: sourcePath,
        projectPathname: projectPathname,
        source: source,
        file: entryRelativePath
      });
    }

    var sourceRelativePath = pathnameToRelativePath(sourcePathname, projectPathname);
    var isAbstract = arrayOfAbstractHref.includes("file://".concat(projectPathname).concat(sourceRelativePath));
    var dependencyContent;
    var sourcesContent = rollupSourcemap.sourcesContent || [];

    if (index in sourcesContent) {
      // abstract ressource cannot be found on filesystem
      // so trust what we found in sourcesContent
      if (isAbstract) {
        dependencyContent = sourcesContent[index];
      } // .json file source content is not the one inside the file
      // because jsenv-rollup-plugin transforms it to
      // export default, so we must set back the
      // right file content
      else if (sourceRelativePath.endsWith(".json")) {
          dependencyContent = readSourceContent({
            projectPathname: projectPathname,
            sourceRelativePath: sourceRelativePath,
            entryRelativePath: entryRelativePath
          });
        } else {
          dependencyContent = sourcesContent[index];
        }
    } else {
      if (isAbstract) {
        throw createAbstractSourceMissingError({
          sourceRelativePath: sourceRelativePath,
          entryRelativePath: entryRelativePath
        });
      }

      dependencyContent = readSourceContent({
        projectPathname: projectPathname,
        sourceRelativePath: sourceRelativePath,
        entryRelativePath: entryRelativePath
      });
    }

    dependencyMap[sourceRelativePath] = dependencyContent;
  });
  return dependencyMap;
};

var readSourceContent = function readSourceContent(_ref4) {
  var projectPathname = _ref4.projectPathname,
      sourceRelativePath = _ref4.sourceRelativePath,
      entryRelativePath = _ref4.entryRelativePath;
  var sourcePath = pathnameToOperatingSystemPath("".concat(projectPathname).concat(sourceRelativePath)); // this could be async but it's ok for now
  // making it async could be harder than it seems
  // because sourcesContent must be in sync with sources

  try {
    var buffer = fs.readFileSync(sourcePath);
    return String(buffer);
  } catch (e) {
    if (e && e.code === "ENOENT") {
      throw createSourceNotFoundError({
        sourcePath: sourcePath,
        projectPathname: projectPathname,
        source: sourceRelativePath,
        file: entryRelativePath
      });
    }

    throw e;
  }
};

var createAbstractSourceMissingError = function createAbstractSourceMissingError(_ref5) {
  var source = _ref5.source,
      file = _ref5.file;
  return new Error("an abstract file source content is missing.\nsource: ".concat(source, "\nfile: ").concat(file));
};

var createSourceNotFoundError = function createSourceNotFoundError(_ref6) {
  var sourcePath = _ref6.sourcePath,
      projectPathname = _ref6.projectPathname,
      source = _ref6.source,
      file = _ref6.file;
  return new Error("a file source cannot be found.\nsource path: ".concat(sourcePath, "\nproject path: ").concat(pathnameToOperatingSystemPath(projectPathname), "\nsource: ").concat(source, "\nfile: ").concat(file));
};

var createSourceOutsideProjectError = function createSourceOutsideProjectError(_ref7) {
  var sourcePath = _ref7.sourcePath,
      projectPathname = _ref7.projectPathname,
      source = _ref7.source,
      file = _ref7.file;
  return new Error("a file source is not inside project.\nsource path: ".concat(sourcePath, "\nproject path: ").concat(pathnameToOperatingSystemPath(projectPathname), "\nsource: ").concat(source, "\nfile: ").concat(file));
};

exports.bundleToCompilationResult = bundleToCompilationResult;
exports.generateBundle = generateBundle;
exports.generateCommonJsBundle = generateCommonJsBundle;
exports.generateGlobalBundle = generateGlobalBundle;
exports.generateSystemJsBundle = generateSystemJsBundle;
//# sourceMappingURL=main.js.map