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

'use strict';

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

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

function _typeof(obj) {
  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof(obj);
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(source, true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(source).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }

  return target;
}

function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};

  var target = _objectWithoutPropertiesLoose(source, excluded);

  var key, 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;
}

function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
}

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

    return arr2;
  }
}

function _iterableToArray(iter) {
  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
}

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

// eslint-disable-next-line no-undef
if ((typeof globalThis === "undefined" ? "undefined" : _typeof(globalThis)) !== "object") {
  var globalObject;

  if (undefined) {
    globalObject = undefined;
  } else {
    // eslint-disable-next-line no-extend-native
    Object.defineProperty(Object.prototype, "__global__", {
      get: function get() {
        return this;
      },
      configurable: true
    }); // eslint-disable-next-line no-undef

    globalObject = __global__;
    delete Object.prototype.__global__;
  }

  globalObject.globalThis = globalObject;
}

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/85ea5b0b50bca952b26f895e56bf2165ab9fcc92/packages/babel-preset-env/data/plugins.json#L1
// 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",
    safari: "9",
    node: "4",
    ios: "9",
    opera: "28",
    electron: "0.24"
  },
  "transform-literals": {
    chrome: "44",
    edge: "12",
    firefox: "53",
    safari: "9",
    node: "4",
    ios: "9",
    opera: "31",
    electron: "0.31"
  },
  "transform-function-name": {
    chrome: "51",
    firefox: "53",
    safari: "10",
    node: "6.5",
    ios: "10",
    opera: "38",
    electron: "1.2"
  },
  "transform-arrow-functions": {
    chrome: "47",
    edge: "13",
    firefox: "45",
    safari: "10",
    node: "6",
    ios: "10",
    opera: "34",
    electron: "0.36"
  },
  "transform-block-scoped-functions": {
    chrome: "41",
    edge: "12",
    firefox: "46",
    safari: "10",
    node: "4",
    ie: "11",
    ios: "10",
    opera: "28",
    electron: "0.24"
  },
  "transform-classes": {
    chrome: "46",
    edge: "13",
    firefox: "45",
    safari: "10",
    node: "5",
    ios: "10",
    opera: "33",
    electron: "0.36"
  },
  "transform-object-super": {
    chrome: "46",
    edge: "13",
    firefox: "45",
    safari: "10",
    node: "5",
    ios: "10",
    opera: "33",
    electron: "0.36"
  },
  "transform-shorthand-properties": {
    chrome: "43",
    edge: "12",
    firefox: "33",
    safari: "9",
    node: "4",
    ios: "9",
    opera: "30",
    electron: "0.29"
  },
  "transform-duplicate-keys": {
    chrome: "42",
    edge: "12",
    firefox: "34",
    safari: "9",
    node: "4",
    ios: "9",
    opera: "29",
    electron: "0.27"
  },
  "transform-computed-properties": {
    chrome: "44",
    edge: "12",
    firefox: "34",
    safari: "7.1",
    node: "4",
    ios: "8",
    opera: "31",
    electron: "0.31"
  },
  "transform-for-of": {
    chrome: "51",
    edge: "15",
    firefox: "53",
    safari: "10",
    node: "6.5",
    ios: "10",
    opera: "38",
    electron: "1.2"
  },
  "transform-sticky-regex": {
    chrome: "49",
    edge: "13",
    firefox: "3",
    safari: "10",
    node: "6",
    ios: "10",
    opera: "36",
    electron: "1"
  },
  "transform-dotall-regex": {
    chrome: "62",
    safari: "11.1",
    node: "8.10",
    ios: "11.3",
    opera: "49",
    electron: "3"
  },
  "transform-unicode-regex": {
    chrome: "50",
    edge: "13",
    firefox: "46",
    safari: "10",
    node: "6",
    ios: "10",
    opera: "37",
    electron: "1.1"
  },
  "transform-spread": {
    chrome: "46",
    edge: "13",
    firefox: "36",
    safari: "10",
    node: "5",
    ios: "10",
    opera: "33",
    electron: "0.36"
  },
  "transform-parameters": {
    chrome: "49",
    edge: "14",
    firefox: "53",
    safari: "10",
    node: "6",
    ios: "10",
    opera: "36",
    electron: "1"
  },
  "transform-destructuring": {
    chrome: "51",
    firefox: "53",
    safari: "10",
    node: "6.5",
    ios: "10",
    opera: "38",
    electron: "1.2"
  },
  "transform-block-scoping": {
    chrome: "49",
    edge: "14",
    firefox: "51",
    safari: "10",
    node: "6",
    ios: "10",
    opera: "36",
    electron: "1"
  },
  "transform-typeof-symbol": {
    chrome: "38",
    edge: "12",
    firefox: "36",
    safari: "9",
    node: "0.12",
    ios: "9",
    opera: "25",
    electron: "0.2"
  },
  "transform-new-target": {
    chrome: "46",
    edge: "14",
    firefox: "41",
    safari: "10",
    node: "5",
    ios: "10",
    opera: "33",
    electron: "0.36"
  },
  "transform-regenerator": {
    chrome: "50",
    edge: "13",
    firefox: "53",
    safari: "10",
    node: "6",
    ios: "10",
    opera: "37",
    electron: "1.1"
  },
  "transform-exponentiation-operator": {
    chrome: "52",
    edge: "14",
    firefox: "52",
    safari: "10.1",
    node: "7",
    ios: "10.3",
    opera: "39",
    electron: "1.3"
  },
  "transform-async-to-generator": {
    chrome: "55",
    edge: "15",
    firefox: "52",
    safari: "10.1",
    node: "7.6",
    ios: "10.3",
    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: "10.1",
    node: "7.6",
    ios: "10.3",
    opera: "42",
    electron: "1.6"
  },
  "proposal-async-generator-functions": {
    chrome: "63",
    firefox: "57",
    safari: "12",
    opera: "50",
    electron: "3"
  },
  "proposal-object-rest-spread": {
    chrome: "60",
    firefox: "55",
    safari: "11.1",
    node: "8.3",
    ios: "11.3",
    opera: "47",
    electron: "2"
  },
  "proposal-unicode-property-regex": {
    chrome: "64",
    safari: "11.1",
    ios: "11.3",
    opera: "51",
    electron: "3"
  },
  "proposal-json-strings": {},
  "proposal-optional-catch-binding": {
    chrome: "66",
    firefox: "58",
    safari: "11.1",
    ios: "11.3",
    opera: "53",
    electron: "3"
  }
};

// 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 = {};

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({}, 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 = _objectSpread2({}, 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: _objectSpread2({}, 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: _objectSpread2({}, 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 BEST_ID = "best";
var OTHERWISE_ID = "otherwise";

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: _objectSpread2({}, babelPluginMap, {}, polyfillConfigMap),
    // here we should throw if key conflict on babelCompatMap/polyfillCompatMap
    featureCompatMap: _objectSpread2({}, 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(featureConfigMap) !== "object") throw new TypeError("featureConfigMap must be an object, got ".concat(featureConfigMap));
  if (_typeof(featureCompatMap) !== "object") throw new TypeError("featureCompatMap must be an object, got ".concat(featureCompatMap));
  if (_typeof(platformScoreMap) !== "object") throw new TypeError("platformScoreMap must be an object, got ".concat(platformScoreMap));
  if (_typeof(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({}, 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({}, 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({}, 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 browserScoreMap = {
  // 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 your specific audience
  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
  }
};

// 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
};

// 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(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 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 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 assertImportMap = function assertImportMap(value) {
  if (value === null) {
    throw new TypeError("an importMap must be an object, got null");
  }

  var type = _typeof(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));
  }
};

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

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

  var _importMap$imports = importMap.imports,
      imports = _importMap$imports === void 0 ? {} : _importMap$imports,
      _importMap$scopes = importMap.scopes,
      scopes = _importMap$scopes === void 0 ? {} : _importMap$scopes;

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

    var importerPathname = hrefToPathname(importerHref); // here instead or taking the first match
    // take the best match instead
    // check the importMap spec repo to find how
    // (bsically most char matching is a win)
    // (or just the longest scope)

    var matchingPathnamePattern = Object.keys(scopes).find(function (pathnameMatchPattern) {
      return match(importerPathname, pathnameMatchPattern);
    });

    if (matchingPathnamePattern) {
      var scopeImports = scopes[matchingPathnamePattern];
      return applyImports({
        href: href,
        imports: scopeImports // scopePattern: matchingPathnamePattern,

      });
    }
  }

  return applyImports({
    href: href,
    imports: imports
  });
};

var applyImports = function applyImports(_ref2) {
  var href = _ref2.href,
      imports = _ref2.imports;
  var modulePathname = hrefToPathname(href);
  var pathnamePatternArray = Object.keys(imports);
  var i = 0;

  while (i < pathnamePatternArray.length) {
    var pathnamePattern = pathnamePatternArray[i];
    i++;
    var matchResult = match(modulePathname, pathnamePattern);
    if (!matchResult) continue;
    var before = matchResult.before,
        after = matchResult.after;
    var moduleOrigin = hrefToOrigin(href);
    var replacement = imports[pathnamePattern];
    return "".concat(moduleOrigin).concat(before).concat(replacement).concat(after);
  }

  return href;
};

var match = function match(pathname, pattern) {
  var patternHasLeadingSlash = pattern[0] === "/";
  var patternHasTrailingSlash = pattern[pattern.length - 1] === "/"; // pattern : '/foo/'

  if (patternHasLeadingSlash && patternHasTrailingSlash) {
    var index = pathname.indexOf(pattern); // pathname: '/fo/bar'
    // pathname: '/foobar'

    if (index === -1) return null; // pathname: '/foo/bar'

    return {
      before: pathname.slice(0, index),
      after: pathname.slice(index + pattern.length)
    };
  } // pattern: '/foo'


  if (patternHasLeadingSlash && !patternHasTrailingSlash) {
    // pathname: '/fo', /foobar'
    if (pathname !== pattern) return null; // pathname: '/foo'

    return {
      before: "",
      after: ""
    };
  } // pattern: 'foo/'


  if (!patternHasLeadingSlash && patternHasTrailingSlash) {
    var _index = pathname.indexOf("/".concat(pattern)); // pathname: '/fo/bar'


    if (_index === -1) return null; // pathname: '/bar/foo/file.js'

    if (_index !== 0) return null; // pathname: '/foo', '/foo/bar'

    return {
      before: "",
      after: pathname.slice(pattern.length + 1)
    };
  } // pattern 'foo'
  // pathname: '/fo', /foobar'


  if (pathname.slice(1) !== pattern) return null; // pathname: '/foo'

  return {
    before: "",
    after: ""
  };
};

var sortImportMap = function sortImportMap(importMap) {
  assertImportMap(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).forEach(function (name) {
    sortedImports[name] = imports[name];
  });
  return sortedImports;
};

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

var compareLengthOrLocaleCompare = 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(a, b);
  };

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

var composeTwoImportMaps = function composeTwoImportMaps(leftImportMap, rightImportMap) {
  assertImportMap(leftImportMap);
  assertImportMap(rightImportMap);
  return sortImportMap({
    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 _objectSpread2({}, 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 = _objectSpread2({}, leftScopes);

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

// 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(_ref) {
  var specifier = _ref.specifier;
  return specifier;
};

var isSchemeRelativeSpecifier = function isSchemeRelativeSpecifier(specifier) {
  return specifier.slice(0, 2) === "//";
};
var resolveSchemeRelativeSpecifier = function resolveSchemeRelativeSpecifier(_ref) {
  var importer = _ref.importer,
      specifier = _ref.specifier;
  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(_ref) {
  var importer = _ref.importer,
      specifier = _ref.specifier;
  var importerOrigin = hrefToOrigin(importer);
  return "".concat(importerOrigin, "/").concat(specifier.slice(1));
};

// "../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(_ref) {
  var importer = _ref.importer,
      specifier = _ref.specifier;
  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.startsWith("./")) {
    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(_ref) {
  var importer = _ref.importer,
      specifier = _ref.specifier;
  var importerOrigin = hrefToOrigin(importer);
  return "".concat(importerOrigin, "/").concat(specifier);
};

var resolveImport = function resolveImport(_ref) {
  var importer = _ref.importer,
      specifier = _ref.specifier;

  if (isAbsoluteSpecifier(specifier)) {
    return resolveAbsoluteSpecifier({
      importer: importer,
      specifier: specifier
    });
  }

  if (!importer) {
    throw new Error("missing importer to resolve relative specifier.\nimporter: ".concat(importer, "\nspecifier: ").concat(specifier));
  }

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

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

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

  return resolveBareSpecifier({
    importer: importer,
    specifier: specifier
  });
};

var resolvePath = function resolvePath(_ref) {
  var specifier = _ref.specifier,
      importer = _ref.importer,
      importMap = _ref.importMap,
      _ref$defaultExtension = _ref.defaultExtension,
      defaultExtension = _ref$defaultExtension === void 0 ? true : _ref$defaultExtension;
  var resolvedImport = resolveImport({
    specifier: specifier,
    importer: importer
  });
  var remappedImport = importMap ? applyImportMap({
    importMap: importMap,
    href: resolvedImport,
    importerHref: importer
  }) : resolvedImport;

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

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

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

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

  return remappedImport;
};

var nodeRequire = require;
var filenameContainsBackSlashes = __filename.indexOf("\\") > -1;
var url = filenameContainsBackSlashes ? "file://".concat(__filename.replace(/\\/g, "/")) : "file://".concat(__filename);

var jsenvBundlingProjectPath;

if (typeof __filename === "string") {
  jsenvBundlingProjectPath = path.resolve(__filename, "../../../"); // get ride of dist/node/main.js
} else {
  var selfPathname = hrefToPathname(url);
  var selfPath = pathnameToOperatingSystemPath(selfPathname);
  jsenvBundlingProjectPath = path.resolve(selfPath, "../../"); // 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(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(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(function (path) {
  return _await(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(function (path) {
  return _await(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 assertFileSync = function assertFileSync(path) {
  var stats;

  try {
    stats = fs.statSync(path);
  } catch (e) {
    if (e.code === "ENOENT") {
      throw new Error("file not found on filesystem.\npath: ".concat(path));
    }

    throw e;
  }

  var entry = statsToEntry(stats);

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

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 LOG_LEVEL_OFF = "off";
var LOG_LEVEL_ERRORS = "errors";
var LOG_LEVEL_ERRORS_AND_WARNINGS = "errors+warnings";
var LOG_LEVEL_ERRORS_WARNINGS_AND_LOGS = "errors+warnings+logs";
var LOG_LEVEL_MAXIMUM = "maximum";
var createLogger = function createLogger(_ref) {
  var _ref$logLevel = _ref.logLevel,
      logLevel = _ref$logLevel === void 0 ? LOG_LEVEL_ERRORS_WARNINGS_AND_LOGS : _ref$logLevel;

  if (logLevel === LOG_LEVEL_MAXIMUM) {
    return {
      logTrace: logTrace,
      log: log,
      logWarning: logWarning,
      logError: logError
    };
  }

  if (logLevel === LOG_LEVEL_ERRORS_WARNINGS_AND_LOGS) {
    return {
      logTrace: logTraceDisabled,
      log: log,
      logWarning: logWarning,
      logError: logError
    };
  }

  if (logLevel === LOG_LEVEL_ERRORS_AND_WARNINGS) {
    return {
      logTrace: logTraceDisabled,
      log: logDisabled,
      logWarning: logWarning,
      logError: logError
    };
  }

  if (logLevel === LOG_LEVEL_ERRORS) {
    return {
      logTrace: logTraceDisabled,
      log: logDisabled,
      logWarning: logWarningDisabled,
      logError: logError
    };
  }

  if (logLevel === LOG_LEVEL_OFF) {
    return {
      logTrace: logTraceDisabled,
      log: logDisabled,
      logWarning: logWarningDisabled,
      logError: logErrorDisabled
    };
  }

  throw new Error("unexpected logLevel.\nlogLevel: ".concat(logLevel, "\nallowed log levels: ").concat(LOG_LEVEL_OFF, ", ").concat(LOG_LEVEL_ERRORS, ", ").concat(LOG_LEVEL_ERRORS_AND_WARNINGS, ", ").concat(LOG_LEVEL_ERRORS_WARNINGS_AND_LOGS, ", ").concat(LOG_LEVEL_MAXIMUM));
};
var logTrace = console.trace;

var logTraceDisabled = function logTraceDisabled() {};

var log = console.log;

var logDisabled = function logDisabled() {};

var logWarning = console.warn;

var logWarningDisabled = function logWarningDisabled() {};

var logError = console.error;

var logErrorDisabled = function logErrorDisabled() {};

var createRollupPluginExternalGlobal = nodeRequire("rollup-plugin-external-globals");

var createImportFromGlobalRollupPlugin = function createImportFromGlobalRollupPlugin(_ref) {
  var platformGlobalName = _ref.platformGlobalName;
  if (typeof platformGlobalName !== "string") throw new TypeError("platformGlobalName must be a string, got ".concat(platformGlobalName, "."));
  return createRollupPluginExternalGlobal({
    global: platformGlobalName
  }, {
    exclude: [/\.json$/]
  });
};

// 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 _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() {}

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$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 promiseSequence = function promiseSequence(callbackArray) {
  var values = [];

  var visit = _async$1(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$1(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$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;
}

function _empty$1() {}

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

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

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 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$2(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$2(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$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 readFilePromisified = util.promisify(fs.readFile);

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 fileRead = _async$3(function (file) {
  return _await$3(readFilePromisified(file), function (buffer) {
    return buffer.toString();
  });
});

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

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

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

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

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 fileWrite = _async$4(function (file, content) {
  return _await$4(fileMakeDirname(file), function () {
    return writeFilePromisified(file, content);
  });
});

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

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

var importMapToVsCodeConfigPaths = function importMapToVsCodeConfigPaths(_ref) {
  var _ref$imports = _ref.imports,
      imports = _ref$imports === void 0 ? {} : _ref$imports;
  var paths = {};

  var handleImportsAt = function handleImportsAt(pathPattern, remappingValue) {
    var path;

    if (pathPattern.endsWith("/")) {
      path = "".concat(pathPattern, "*");
    } else {
      path = pathPattern;
    }

    var remappingArray = typeof remappingValue === "string" ? [remappingValue] : remappingValue;
    var candidates = remappingArray.filter(function (remapping) {
      return !remapping.endsWith("/");
    }).map(function (remapping) {
      return ".".concat(remapping);
    });

    if (candidates.length) {
      if (path in paths) {
        paths[path] = [].concat(_toConsumableArray(paths[path]), _toConsumableArray(candidates));
      } else {
        paths[path] = candidates;
      }
    }
  };

  Object.keys(imports).forEach(function (importPattern) {
    handleImportsAt(importPattern, imports[importPattern]);
  });
  return paths;
};

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 _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 _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;
}

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

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

  return then(result);
}

function _empty$2() {}

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

var generateImportMapForNodeModules = _async$8(function (_ref) {
  var projectPath = _ref.projectPath,
      _ref$rootProjectPath = _ref.rootProjectPath,
      rootProjectPath = _ref$rootProjectPath === void 0 ? projectPath : _ref$rootProjectPath,
      _ref$importMapRelativ = _ref.importMapRelativePath,
      importMapRelativePath = _ref$importMapRelativ === void 0 ? "/importMap.json" : _ref$importMapRelativ,
      _ref$inputImportMap = _ref.inputImportMap,
      inputImportMap = _ref$inputImportMap === void 0 ? {} : _ref$inputImportMap,
      _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,
      _ref$writeImportMapFi = _ref.writeImportMapFile,
      writeImportMapFile = _ref$writeImportMapFi === void 0 ? false : _ref$writeImportMapFi,
      _ref$logImportMapFile = _ref.logImportMapFilePath,
      logImportMapFilePath = _ref$logImportMapFile === void 0 ? true : _ref$logImportMapFile,
      _ref$throwUnhandled = _ref.throwUnhandled,
      throwUnhandled = _ref$throwUnhandled === void 0 ? true : _ref$throwUnhandled,
      _ref$writeJsConfigFil = _ref.writeJsConfigFile,
      writeJsConfigFile = _ref$writeJsConfigFil === void 0 ? false : _ref$writeJsConfigFil,
      _ref$logJsConfigFileP = _ref.logJsConfigFilePath,
      logJsConfigFilePath = _ref$logJsConfigFileP === void 0 ? true : _ref$logJsConfigFileP;
  return catchAsyncFunctionCancellation(_async$8(function () {
    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 start = _async$8(function () {
      return _await$8(readPackageData({
        path: pathnameToOperatingSystemPath(projectPackagePathname),
        onWarn: onWarn
      }), function (projectPackageData) {
        return _await$8(visitProjectPackage({
          packagePathname: projectPackagePathname,
          packageData: projectPackageData
        }), function () {
          var nodeModuleImportMap = {
            imports: imports,
            scopes: scopes
          };
          var importMap = composeTwoImportMaps(inputImportMap, nodeModuleImportMap);
          var sortedImportMap = sortImportMap(importMap);
          return _invoke$1(function () {
            if (writeImportMapFile) {
              var importMapPath = pathnameToOperatingSystemPath("".concat(projectPathname).concat(importMapRelativePath));
              return _await$8(fileWrite(importMapPath, JSON.stringify(sortedImportMap, null, "  ")), function () {
                if (logImportMapFilePath) {
                  console.log("-> ".concat(importMapPath));
                }
              });
            }
          }, function () {
            return _invoke$1(function () {
              if (writeJsConfigFile) {
                var jsConfigPath = pathnameToOperatingSystemPath("".concat(projectPathname, "/jsconfig.json"));
                return _catch$1(function () {
                  var jsConfig = {
                    compilerOptions: {
                      baseUrl: ".",
                      paths: _objectSpread2({
                        "/*": ["./*"]
                      }, importMapToVsCodeConfigPaths(importMap))
                    }
                  };
                  return _await$8(fileWrite(jsConfigPath, JSON.stringify(jsConfig, null, "  ")), function () {
                    if (logJsConfigFilePath) {
                      console.log("-> ".concat(jsConfigPath));
                    }
                  });
                }, function (e) {
                  if (e.code !== "ENOENT") {
                    throw e;
                  }
                });
              }
            }, function (_result2) {
              return  sortedImportMap;
            });
          });
        });
      });
    });

    var visitProjectPackage = _async$8(function (_ref3) {
      var packagePathname = _ref3.packagePathname,
          packageData = _ref3.packageData;
      return _awaitIgnored$1(visit({
        packagePathname: packagePathname,
        packageData: packageData,
        packageName: packageData.name,
        importerPackagePathname: packagePathname
      }));
    });

    var seen = {};

    var visit = _async$8(function (_ref4) {
      var packagePathname = _ref4.packagePathname,
          packageData = _ref4.packageData,
          packageName = _ref4.packageName,
          importerPackagePathname = _ref4.importerPackagePathname;

      if (packagePathname in seen) {
        if (seen[packagePathname].includes(importerPackagePathname)) return;
        seen[packagePathname].push(importerPackagePathname);
      } else {
        seen[packagePathname] = [importerPackagePathname];
      }

      return _await$8(visitPackage({
        packagePathname: packagePathname,
        packageData: packageData,
        packageName: packageName,
        importerPackagePathname: importerPackagePathname
      }), function () {
        return _awaitIgnored$1(visitDependencies({
          packagePathname: packagePathname,
          packageData: packageData
        }));
      });
    });

    var visitPackage = _async$8(function (_ref5) {
      var packagePathname = _ref5.packagePathname,
          packageData = _ref5.packageData,
          packageName = _ref5.packageName,
          importerPackagePathname = _ref5.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 (_ref6) {
      var packagePathname = _ref6.packagePathname,
          packageData = _ref6.packageData,
          packageName = _ref6.packageName,
          _ref6$packagePathInfo = _ref6.packagePathInfo,
          packageIsRoot = _ref6$packagePathInfo.packageIsRoot,
          packageIsProject = _ref6$packagePathInfo.packageIsProject,
          importerPackageIsRoot = _ref6$packagePathInfo.importerPackageIsRoot,
          importerName = _ref6$packagePathInfo.importerName,
          actualRelativePath = _ref6$packagePathInfo.actualRelativePath,
          expectedRelativePath = _ref6$packagePathInfo.expectedRelativePath;
      if (packageIsRoot) return;
      if (packageIsProject) return;
      return _await$8(resolvePackageMain({
        packagePathname: packagePathname,
        packageData: packageData,
        onWarn: function onWarn() {}
      }), function (main) {
        // it's possible to have no main
        // like { main: "" } in package.json
        // or a main that does not lead to an actual file
        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
          });
        }
      });
    });

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

      if (_typeof(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(_ref8) {
      var packagePathname = _ref8.packagePathname,
          packageName = _ref8.packageName,
          packageData = _ref8.packageData,
          _ref8$packagePathInfo = _ref8.packagePathInfo,
          importerName = _ref8$packagePathInfo.importerName,
          packageIsRoot = _ref8$packagePathInfo.packageIsRoot,
          actualRelativePath = _ref8$packagePathInfo.actualRelativePath,
          expectedRelativePath = _ref8$packagePathInfo.expectedRelativePath;
      if (packageIsRoot) return;
      var packageExports = packageData.exports;

      if (_typeof(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 (_ref9) {
      var packagePathname = _ref9.packagePathname,
          packageData = _ref9.packageData;
      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 _await$8(findDependency({
          packagePathname: packagePathname,
          packageData: packageData,
          dependencyName: dependencyName,
          dependencyType: dependency.type,
          dependencyVersionPattern: dependency.versionPattern
        }), function (dependencyData) {
          if (!dependencyData) {
            return;
          }

          var dependencyPackagePathname = dependencyData.packagePathname,
              dependencyPackageData = dependencyData.packageData;
          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;
      imports[from] = to;
    };

    var addScopedImportMapping = function addScopedImportMapping(_ref12) {
      var scope = _ref12.scope,
          from = _ref12.from,
          to = _ref12.to;
      scopes[scope] = _objectSpread2({}, scopes[scope] || {}, _defineProperty({}, 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;
    };

    var promise = start();
    return throwUnhandled ? promise.catch(function (e) {
      setTimeout(function () {
        throw e;
      });
    }) : promise;
  }));
});

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

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

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

var BABEL_HELPERS_FACADE_PATH = "/.jsenv/babelHelpers.js";
var GLOBAL_THIS_FACADE_PATH = "/.jsenv/helpers/global-this.js";
var generateSpecifierDynamicMapOption = function generateSpecifierDynamicMapOption() {
  var _ref;

  return _ref = {}, _defineProperty(_ref, GLOBAL_THIS_FACADE_PATH, function () {
    return generateGlobalThisSource();
  }), _defineProperty(_ref, BABEL_HELPERS_FACADE_PATH, function () {
    return {
      code: buildExternalHelpers(undefined, "module"),
      // babel helper must not be retransformed
      skipTransform: true
    };
  }), _ref;
};

var generateGlobalThisSource = function generateGlobalThisSource() {
  return "\n// eslint-disable-next-line no-undef\nif (typeof globalThis !== \"object\") {\n  let globalObject\n\n  if (this) {\n    globalObject = this\n  } else {\n    // eslint-disable-next-line no-extend-native\n    Object.defineProperty(Object.prototype, \"__global__\", {\n      get() {\n        return this\n      },\n      configurable: true,\n    })\n    // eslint-disable-next-line no-undef\n    globalObject = __global__\n    delete Object.prototype.__global__\n  }\n\n  globalObject.globalThis = globalObject\n}";
};

var _require2$1 = nodeRequire("@babel/helper-module-imports"),
    addNamed = _require2$1.addNamed; // for reference this is how it's done to reference
// a global babel helper object instead of using
// a named import
// https://github.com/babel/babel/blob/master/packages/babel-plugin-external-helpers/src/index.js
// named import approach found here:
// https://github.com/rollup/rollup-plugin-babel/blob/18e4232a450f320f44c651aa8c495f21c74d59ac/src/helperPlugin.js#L1


var createReplaceBabelHelperByNamedImportsBabelPlugin = function createReplaceBabelHelperByNamedImportsBabelPlugin(_ref) {
  var babelHelpersFacadePath = _ref.babelHelpersFacadePath;
  return {
    pre: function pre(file) {
      var cachedHelpers = {};
      file.set("helperGenerator", function (name) {
        if (!file.availableHelper(name)) {
          return undefined;
        }

        if (cachedHelpers[name]) {
          return cachedHelpers[name];
        } // https://github.com/babel/babel/tree/master/packages/babel-helper-module-imports


        var helper = addNamed(file.path, name, babelHelpersFacadePath);
        cachedHelpers[name] = helper;
        return helper;
      });
    }
  };
};

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

var createForceImportsBabelPlugin = function createForceImportsBabelPlugin(_ref) {
  var sideEffectImportRelativePathArray = _ref.sideEffectImportRelativePathArray;
  return {
    pre: function pre(file) {
      var opts = file.path.hub.file.opts;
      var isFileItself = sideEffectImportRelativePathArray.some(function (relativePath) {
        return relativePath.slice(1) === opts.filenameRelative;
      });
      if (isFileItself) return;
      sideEffectImportRelativePathArray.forEach(function (relativePath) {
        addSideEffect(file.path, relativePath);
      });
    }
  };
};

// https://github.com/cfware/babel-plugin-bundled-import-meta/blob/master/index.js
var _require2$3 = nodeRequire("@babel/helper-module-imports"),
    addNamed$1 = _require2$3.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$1(programPath, importMetaPropertyId, importMetaFacadePath);
            metaPropertyMap[propertyName].forEach(function (path) {
              path.replaceWith(result);
            });
          });
        }
      }
    };
  };
};

var generateBabelPluginMapOption = function generateBabelPluginMapOption(_ref) {
  var projectPathname = _ref.projectPathname,
      format = _ref.format,
      babelPluginMap = _ref.babelPluginMap,
      featureNameArray = _ref.featureNameArray,
      globalThisHelperRelativePath = _ref.globalThisHelperRelativePath;
  return _objectSpread2({}, generateBabelPluginMapSubset({
    babelPluginMap: babelPluginMap,
    featureNameArray: featureNameArray
  }), {}, generateBabelPluginMapForBundle({
    projectPathname: projectPathname,
    format: format,
    globalThisHelperRelativePath: GLOBAL_THIS_FACADE_PATH,
    babelHelpersFacadePath: BABEL_HELPERS_FACADE_PATH
  }));
};

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 projectPathname = _ref3.projectPathname,
      format = _ref3.format,
      globalThisHelperRelativePath = _ref3.globalThisHelperRelativePath,
      babelHelpersFacadePath = _ref3.babelHelpersFacadePath;
  var bundleBabelPluginMap = {};
  var forcedImportsBabelPlugin = createForceImportsBabelPlugin({
    projectPathname: projectPathname,
    sideEffectImportRelativePathArray: [globalThisHelperRelativePath]
  });
  bundleBabelPluginMap["force-imports"] = [forcedImportsBabelPlugin];
  var replaceBabelHelperByNamedImportsBabelPlugin = createReplaceBabelHelperByNamedImportsBabelPlugin({
    babelHelpersFacadePath: babelHelpersFacadePath
  });
  bundleBabelPluginMap["replace-babel-helper-by-named-imports"] = [replaceBabelHelperByNamedImportsBabelPlugin];

  if (format === "commonjs" || format === "global") {
    var importMetaFacadePath;

    if (projectPathname === jsenvBundlingProjectPathname) {
      importMetaFacadePath = "/src/babel-plugin-map/import-meta-".concat(format, ".js");
    } else {
      importMetaFacadePath = "@jsenv/bundling/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$2(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$2(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, _objectSpread2({
            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 _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 _catch$2(body, recover) {
  try {
    var result = body();
  } catch (e) {
    return recover(e);
  }

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

  return result;
}

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

var readProjectImportMap = _async$a(function (_ref) {
  var projectPathname = _ref.projectPathname,
      importMapRelativePath = _ref.importMapRelativePath;
  return importMapRelativePath ? _catch$2(function () {
    return _await$a(fileRead(pathnameToOperatingSystemPath("".concat(projectPathname, "/").concat(importMapRelativePath))), JSON.parse);
  }, function (e) {
    if (e && e.code === "ENOENT") {
      return {};
    }

    throw e;
  }) : {};
});

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$4 = nodeRequire("@jsenv/core"),
    transformSource = _require2$4.transformSource,
    jsenvTransform = _require2$4.jsenvTransform,
    findAsyncPluginNameInBabelPluginMap = _require2$4.findAsyncPluginNameInBabelPluginMap;

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 _require3 = nodeRequire("terser"),
    minifyCode = _require3.minify;

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

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

  return then(result);
}

function _empty$3() {}

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

var createJsenvRollupPlugin = _async$b(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      projectPathname = _ref.projectPathname,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      _ref$importMapForBund = _ref.importMapForBundle,
      importMapForBundle = _ref$importMapForBund === void 0 ? {} : _ref$importMapForBund,
      specifierMap = _ref.specifierMap,
      specifierDynamicMap = _ref.specifierDynamicMap,
      _ref$origin = _ref.origin,
      origin = _ref$origin === void 0 ? "http://example.com" : _ref$origin,
      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,
      dir = _ref.dir,
      entryPointMap = _ref.entryPointMap,
      logger = _ref.logger;
  return _await$b(generateImportMapForNodeModules({
    projectPath: jsenvBundlingProjectPath,
    rootProjectPath: pathnameToOperatingSystemPath(projectPathname),
    onWarn: function onWarn(_ref2) {
      var message = _ref2.message;
      return logger.logWarning(message);
    }
  }), function (bundlingImportMap) {
    return _await$b(readProjectImportMap({
      projectPathname: projectPathname,
      importMapRelativePath: importMapRelativePath
    }), function (projectImportMap) {
      var importMap = [importMapForBundle, bundlingImportMap, projectImportMap].reduce(function (previous, current) {
        return composeTwoImportMaps(previous, current);
      }, {});
      var importMapHref = "file://".concat(projectPathname).concat(importMapRelativePath);
      specifierMap = _objectSpread2({}, specifierMap, {}, generateSpecifierMapOption(), _defineProperty({}, "/.jsenv/importMap.json", importMapHref));
      var chunkId = "".concat(Object.keys(entryPointMap)[0], ".js");
      specifierDynamicMap = _objectSpread2({}, specifierDynamicMap, {}, generateSpecifierDynamicMapOption(), _defineProperty({}, "/BUNDLE_CONSTANTS.js", function BUNDLE_CONSTANTSJs() {
        return "export const chunkId = ".concat(JSON.stringify(chunkId));
      }));
      babelPluginMap = generateBabelPluginMapOption({
        projectPathname: projectPathname,
        format: format,
        babelPluginMap: babelPluginMap,
        featureNameArray: featureNameArray
      }); // https://github.com/babel/babel/blob/master/packages/babel-core/src/tools/build-external-helpers.js#L1

      var idSkipTransformArray = [];
      var idLoadMap = {};

      var getRollupGenerateOptions = function getRollupGenerateOptions() {
        return _await$b({});
      };

      var jsenvRollupPlugin = {
        name: "jsenv",
        resolveId: function resolveId(specifier, importer) {
          if (specifier in specifierDynamicMap) {
            var specifierDynamicMapping = specifierDynamicMap[specifier];

            if (typeof specifierDynamicMapping !== "function") {
              throw new Error("specifier inside specifierDynamicMap must be functions, found ".concat(specifierDynamicMapping, " for ").concat(specifier));
            }

            var osPath = pathnameToOperatingSystemPath("".concat(projectPathname).concat(specifier));
            idLoadMap[osPath] = specifierDynamicMapping;
            return osPath;
          }

          if (specifier in specifierMap) {
            var specifierMapping = specifierMap[specifier];

            if (typeof specifierMapping !== "string") {
              throw new Error("specifier inside specifierMap must be strings, found ".concat(specifierMapping, " for ").concat(specifier));
            }

            specifier = specifierMapping; // disable remapping when specifier starts with file://
            // this is the only way for now to explicitely disable remapping
            // to target a specific file on filesystem
            // also remove file:// to keep only the os path
            // otherwise windows and rollup will not be happy when
            // searching the files

            if (specifier.startsWith("file:///")) {
              specifier = specifier.slice("file://".length);
              var path = pathnameToOperatingSystemPath(specifier);
              assertFileSync(path);
              return path;
            }
          }

          if (!importer) {
            if (specifier[0] === "/") specifier = specifier.slice(1);

            var _path = pathnameToOperatingSystemPath("".concat(projectPathname, "/").concat(specifier));

            assertFileSync(_path);
            return _path;
          }

          var importerHref;

          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(origin).concat(pathnameToRelativePath(importer, projectPathname));
          } else if (hrefToScheme(importer)) {
            if (importer.startsWith("file://".concat(projectPathname, "/"))) {
              importerHref = "".concat(origin).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
            });
          }

          var id = resolvePath({
            specifier: specifier,
            importer: importerHref,
            importMap: importMap,
            defaultExtension: importDefaultExtension
          }); // rollup works with operating system path
          // return os path when possible
          // to ensure we can predict sourcemap.sources returned by rollup

          if (id.startsWith("file://")) {
            var pathname = hrefToPathname(id);

            if (!pathnameIsInside(pathname, projectPathname)) {
              throw new Error(createMustBeInsideProjectMessage({
                resolvedId: id,
                specifier: specifier,
                importer: importer,
                projectPathname: projectPathname
              }));
            }

            var _path2 = pathnameToOperatingSystemPath(pathname);

            assertFileSync(_path2);
            return _path2;
          } // we have http or https protocol


          var resolvedIdIsInsideProject = id.startsWith("".concat(origin, "/"));

          if (resolvedIdIsInsideProject) {
            var idPathname = hrefToPathname(id);

            var _path3 = pathnameToOperatingSystemPath("".concat(projectPathname).concat(idPathname));

            assertFileSync(_path3);
            return _path3;
          }

          return id;
        },
        // https://rollupjs.org/guide/en#resolvedynamicimport
        // resolveDynamicImport: (specifier, importer) => {
        // },
        load: _async$b(function (id) {
          var _exit = false;
          return _invoke$3(function () {
            if (id in idLoadMap) {
              return _await$b(idLoadMap[id](), function (returnValue) {
                if (typeof returnValue === "string") {
                  _exit = true;
                  return returnValue;
                }

                if (returnValue.skipTransform) {
                  idSkipTransformArray.push(id);
                }

                _exit = true;
                return returnValue.code;
              });
            }
          }, function (_result) {
            if (_exit) return _result;
            var hasSheme = isWindowsPath(id) ? false : Boolean(hrefToScheme(id));
            var href = hasSheme ? id : "file://".concat(operatingSystemPathToPathname(id));
            return _await$b(fetchHref(href), function (response) {
              var responseStatus = response.status;

              if (!responseStatusIsOk(responseStatus)) {
                if (responseStatus === 404 && href === importMapHref) {
                  // importMap file is optionnal
                  return {
                    code: "export default {}"
                  };
                }

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

              var source = response.body;

              if (id.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$b(fetchHref(resolvedSourceMappingURL), function (sourcemapResponse) {
                var sourcemapResponseStatus = sourcemapResponse.status;

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

                return {
                  code: source,
                  map: JSON.parse(sourcemapResponse.body)
                };
              });
            });
          });
        }),
        // resolveImportMeta: () => {}
        transform: _async$b(function (source, id) {
          if (idSkipTransformArray.includes(id)) {
            return null;
          }

          var sourceHref;

          if (isWindowsPath(id)) {
            sourceHref = "file://".concat(operatingSystemPathToPathname(id));
          } else if (hrefToScheme(id)) {
            sourceHref = id;
          } else {
            sourceHref = "file://".concat(operatingSystemPathToPathname(id));
          }

          return _await$b(transformSource({
            projectPathname: projectPathname,
            source: source,
            sourceHref: sourceHref,
            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
            };
          });
        }),
        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, _objectSpread2({
            sourceMap: true
          }, minifyOptions));

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

      var fetchHref = _async$b(function (href) {
        var _exit2 = 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$3(function () {
          if (href.startsWith("http://")) {
            return _await$b(fetchUsingHttp(href, {
              cancellationToken: cancellationToken
            }), function (response) {
              _exit2 = true;
              return response;
            });
          }
        }, function (_result2) {
          var _exit3 = false;
          if (_exit2) return _result2;
          return _invoke$3(function () {
            if (href.startsWith("https://")) {
              return _await$b(fetchUsingHttp(href, {
                cancellationToken: cancellationToken
              }), function (response) {
                _exit3 = true;
                return response;
              });
            }
          }, function (_result3) {
            var _exit4 = false;
            if (_exit3) return _result3;
            return _invoke$3(function () {
              if (href.startsWith("file:///")) {
                return _await$b(createOperation({
                  cancellationToken: cancellationToken,
                  start: function start() {
                    return fileRead(pathnameToOperatingSystemPath(hrefToPathname(href)));
                  }
                }), function (code) {
                  _exit4 = true;
                  return {
                    status: 200,
                    body: code
                  };
                });
              }
            }, function (_result4) {
              if (_exit4) return _result4;
              throw new Error("unsupported href: ".concat(href));
            });
          });
        });
      });

      return {
        jsenvRollupPlugin: jsenvRollupPlugin,
        relativePathAbstractArray: Object.keys(specifierDynamicMap),
        getRollupGenerateOptions: getRollupGenerateOptions
      };
    });
  });
});

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

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

var createMustBeInsideProjectMessage = function createMustBeInsideProjectMessage(_ref5) {
  var resolvedId = _ref5.resolvedId,
      specifier = _ref5.specifier,
      importer = _ref5.importer,
      projectPathname = _ref5.projectPathname;
  return "\nresolved id must be inside project.\n--- resolved id ---\n".concat(resolvedId, "\n--- specifier ---\n").concat(specifier, "\n--- importer ---\n").concat(importer, "\n--- project path ---\n").concat(pathnameToOperatingSystemPath(projectPathname));
};

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

var transformAsyncInsertedByRollup = _async$b(function (_ref7) {
  var dir = _ref7.dir,
      babelPluginMap = _ref7.babelPluginMap,
      bundle = _ref7.bundle;
  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$b(function (bundleFilename) {
    var bundleInfo = bundle[bundleFilename];
    return _await$b(jsenvTransform({
      inputCode: bundleInfo.code,
      inputMap: bundleInfo.map,
      inputPath: bundleFilename,
      babelPluginMap: _defineProperty({}, asyncPluginName, babelPluginMap[asyncPluginName]),
      transformModuleIntoSystemFormat: false // already done by rollup

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

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

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

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 generateBundleUsingRollup = _async$c(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      rollupParseOptions = _ref.rollupParseOptions,
      rollupGenerateOptions = _ref.rollupGenerateOptions,
      writeOnFileSystem = _ref.writeOnFileSystem;
  return _await$c(createOperation({
    cancellationToken: cancellationToken,
    start: function start() {
      return rollup(_objectSpread2({
        // 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 (warningIsThisIsUndefinedFromGlobalThis(warning)) return;
          warn(warning);
        }
      }, rollupParseOptions));
    }
  }), function (rollupBundle) {
    return _await$c(createOperation({
      cancellationToken: cancellationToken,
      start: function start() {
        if (writeOnFileSystem) {
          return rollupBundle.write(_objectSpread2({
            // 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(_objectSpread2({
          // 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 warningIsThisIsUndefinedFromGlobalThis = function warningIsThisIsUndefinedFromGlobalThis(_ref2) {
  var code = _ref2.code,
      loc = _ref2.loc;
  if (code !== "THIS_IS_UNDEFINED") return false;
  if (!loc) return false;
  var file = loc.file;
  if (file.endsWith("/.jsenv/helpers/global-this.js")) return true;
  if (file.endsWith("\\.jsenv\\helpers\\global-this.js")) return true;
  return false;
};

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$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 _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 _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 bundleWithoutBalancing = _async$d(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      projectPathname = _ref.projectPathname,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      specifierMap = _ref.specifierMap,
      specifierDynamicMap = _ref.specifierDynamicMap,
      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$d(createJsenvRollupPlugin({
    cancellationToken: cancellationToken,
    projectPathname: projectPathname,
    dir: dir,
    entryPointMap: entryPointMap,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    specifierMap: specifierMap,
    specifierDynamicMap: specifierDynamicMap,
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    featureNameArray: Object.keys(babelPluginMap),
    minify: minify,
    format: format,
    logger: logger
  }), function (_ref2) {
    var jsenvRollupPlugin = _ref2.jsenvRollupPlugin,
        relativePathAbstractArray = _ref2.relativePathAbstractArray,
        getRollupGenerateOptions = _ref2.getRollupGenerateOptions;
    var importFromGlobalRollupPlugin = createImportFromGlobalRollupPlugin({
      platformGlobalName: "globalThis"
    });
    logger.logTrace("\nbundle entry points without balancing.\nformat: ".concat(format, "\nentry point names: ").concat(Object.keys(entryPointMap), "\ndir: ").concat(dir, "\nminify: ").concat(minify, "\n"));
    return _call$1(getRollupGenerateOptions, function (rollupGenerateOptions) {
      return _await$d(generateBundleUsingRollup({
        cancellationToken: cancellationToken,
        writeOnFileSystem: writeOnFileSystem,
        rollupParseOptions: {
          input: entryPointMap,
          plugins: [importFromGlobalRollupPlugin, jsenvRollupPlugin],
          external: function external(id) {
            return nativeModulePredicate(id);
          }
        },
        rollupGenerateOptions: _objectSpread2({
          // 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
        }, rollupGenerateOptions, {}, formatOutputOptions)
      }), function (rollupBundle) {
        return {
          rollupBundle: rollupBundle,
          relativePathAbstractArray: relativePathAbstractArray
        };
      });
    });
  });
});

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 bundleWithBalancing = _async$e(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      projectPathname = _ref.projectPathname,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      specifierMap = _ref.specifierMap,
      specifierDynamicMap = _ref.specifierDynamicMap,
      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$e(createJsenvRollupPlugin({
    cancellationToken: cancellationToken,
    projectPathname: projectPathname,
    dir: dir,
    entryPointMap: entryPointMap,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    specifierMap: specifierMap,
    specifierDynamicMap: specifierDynamicMap,
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    featureNameArray: groupMap[compileId].incompatibleNameArray,
    minify: minify,
    format: format,
    logger: logger
  }), function (_ref2) {
    var jsenvRollupPlugin = _ref2.jsenvRollupPlugin;
    var importFromGlobalRollupPlugin = createImportFromGlobalRollupPlugin({
      platformGlobalName: "globalThis"
    });
    logger.logTrace("\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$e(generateBundleUsingRollup({
      cancellationToken: cancellationToken,
      writeOnFileSystem: writeOnFileSystem,
      rollupParseOptions: {
        input: entryPointMap,
        plugins: [importFromGlobalRollupPlugin, jsenvRollupPlugin],
        external: function external(id) {
          return nativeModulePredicate(id);
        }
      },
      rollupGenerateOptions: _objectSpread2({
        dir: dir,
        format: formatToRollupFormat(format),
        sourcemap: true,
        sourceMapExcludeSources: true
      }, formatOutputOptions)
    }), function (rollupBundle) {
      return {
        rollupBundle: rollupBundle
      };
    });
  });
});

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 _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 bundleBalancer = _async$f(function (_ref) {
  var cancellationToken = _ref.cancellationToken,
      projectPathname = _ref.projectPathname,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      specifierMap = _ref.specifierMap,
      specifierDynamicMap = _ref.specifierDynamicMap,
      nativeModulePredicate = _ref.nativeModulePredicate,
      entryPointMap = _ref.entryPointMap,
      babelPluginMap = _ref.babelPluginMap,
      convertMap = _ref.convertMap,
      minify = _ref.minify,
      logLevel = _ref.logLevel,
      format = _ref.format,
      balancerDataClientPathname = _ref.balancerDataClientPathname,
      groupMap = _ref.groupMap,
      writeOnFileSystem = _ref.writeOnFileSystem;
  var logger = createLogger({
    logLevel: logLevel
  });
  var entryPointName = Object.keys(entryPointMap)[0];
  var dir = pathnameToOperatingSystemPath("".concat(projectPathname).concat(bundleIntoRelativePath));
  return _await$f(createJsenvRollupPlugin({
    cancellationToken: cancellationToken,
    projectPathname: projectPathname,
    dir: dir,
    entryPointMap: entryPointMap,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    specifierMap: specifierMap,
    specifierDynamicMap: _objectSpread2({}, specifierDynamicMap, _defineProperty({}, balancerDataClientPathname, function () {
      return "export const entryPointName = ".concat(JSON.stringify(entryPointName), "\n  export const groupMap = ").concat(JSON.stringify(groupMap));
    })),
    babelPluginMap: babelPluginMap,
    convertMap: convertMap,
    featureNameArray: groupMap.otherwise.incompatibleNameArray,
    minify: minify,
    format: format,
    logger: logger
  }), function (_ref2) {
    var jsenvRollupPlugin = _ref2.jsenvRollupPlugin;
    var importFromGlobalRollupPlugin = createImportFromGlobalRollupPlugin({
      platformGlobalName: "globalThis"
    });
    logger.logTrace("\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$f(generateBundleUsingRollup({
      cancellationToken: cancellationToken,
      writeOnFileSystem: writeOnFileSystem,
      rollupParseOptions: {
        input: entryPointMap,
        plugins: [importFromGlobalRollupPlugin, jsenvRollupPlugin],
        external: function external(id) {
          return nativeModulePredicate(id);
        }
      },
      rollupGenerateOptions: {
        dir: dir,
        format: "iife",
        sourcemap: true,
        sourcemapExcludeSources: true
      }
    }), function (rollupBundle) {
      return {
        rollupBundle: rollupBundle
      };
    });
  });
});

var rimraf = nodeRequire("rimraf");

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

// 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 isNativeNodeModuleBareSpecifier = function isNativeNodeModuleBareSpecifier(specifier) {
  return NATIVE_NODE_MODULE_SPECIFIER_ARRAY.includes(specifier);
};

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

var DEFAULT_IMPORT_MAP_RELATIVE_PATH = "/importMap.json";
var DEFAULT_ENTRY_POINT_MAP = {
  main: "index.js"
};
var DEFAULT_NATIVE_MODULE_PREDICATE = function DEFAULT_NATIVE_MODULE_PREDICATE(id) {
  // the global specifier is also in @jsenv/compile-server
  if (id === "global") return true;
  if (isNativeNodeModuleBareSpecifier(id)) return true;
  return false;
};
var DEFAULT_BABEL_PLUGIN_MAP = jsenvBabelPluginMap;
var DEFAULT_PLATFORM_SCORE_MAP = _objectSpread2({}, 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$g(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$4(body, then) {
  var result = body();

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

  return then(result);
}

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 generateBundle = function generateBundle(_ref) {
  var projectPath = _ref.projectPath,
      bundleIntoRelativePath = _ref.bundleIntoRelativePath,
      _ref$cleanBundleInto = _ref.cleanBundleInto,
      cleanBundleInto = _ref$cleanBundleInto === void 0 ? false : _ref$cleanBundleInto,
      importDefaultExtension = _ref.importDefaultExtension,
      _ref$importMapRelativ = _ref.importMapRelativePath,
      importMapRelativePath = _ref$importMapRelativ === void 0 ? DEFAULT_IMPORT_MAP_RELATIVE_PATH : _ref$importMapRelativ,
      importMapForBundle = _ref.importMapForBundle,
      specifierMap = _ref.specifierMap,
      specifierDynamicMap = _ref.specifierDynamicMap,
      _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,
      _ref$logLevel = _ref.logLevel,
      logLevel = _ref$logLevel === void 0 ? LOG_LEVEL_ERRORS_WARNINGS_AND_LOGS : _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,
      defaultBalancerTemplateRelativePath = _ref.defaultBalancerTemplateRelativePath,
      balancerDataClientPathname = _ref.balancerDataClientPathname,
      _ref$platformScoreMap = _ref.platformScoreMap,
      platformScoreMap = _ref$platformScoreMap === void 0 ? DEFAULT_PLATFORM_SCORE_MAP : _ref$platformScoreMap;
  var promise = catchAsyncFunctionCancellation(_async$g(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$g(assertFolder(projectPathname), function () {
      return _invoke$4(function () {
        if (cleanBundleInto) return _awaitIgnored$3(removeFolder(pathnameToOperatingSystemPath("".concat(projectPathname).concat(bundleIntoRelativePath))));
      }, function () {
        if (compileGroupCount === 1) {
          return bundleWithoutBalancing({
            cancellationToken: cancellationToken,
            projectPathname: projectPathname,
            bundleIntoRelativePath: bundleIntoRelativePath,
            importDefaultExtension: importDefaultExtension,
            importMapRelativePath: importMapRelativePath,
            importMapForBundle: importMapForBundle,
            specifierMap: specifierMap,
            specifierDynamicMap: specifierDynamicMap,
            nativeModulePredicate: nativeModulePredicate,
            entryPointMap: entryPointMap,
            babelPluginMap: babelPluginMap,
            convertMap: convertMap,
            minify: minify,
            logLevel: logLevel,
            format: format,
            formatOutputOptions: formatOutputOptions,
            writeOnFileSystem: writeOnFileSystem
          });
        }

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

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

        return _await$g(assertFile(pathnameToOperatingSystemPath("".concat(projectPathname).concat(balancerTemplateRelativePath))), function () {
          var groupMap = generateGroupMap({
            babelPluginMap: babelPluginMap,
            platformScoreMap: platformScoreMap,
            groupCount: compileGroupCount,
            platformAlwaysInsidePlatformScoreMap: platformAlwaysInsidePlatformScoreMap
          });
          return _await$g(Promise.all([generateEntryPointsFolders({
            cancellationToken: cancellationToken,
            projectPathname: projectPathname,
            bundleIntoRelativePath: bundleIntoRelativePath,
            importDefaultExtension: importDefaultExtension,
            importMapRelativePath: importMapRelativePath,
            importMapForBundle: importMapForBundle,
            specifierMap: specifierMap,
            specifierDynamicMap: specifierDynamicMap,
            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,
            importDefaultExtension: importDefaultExtension,
            importMapRelativePath: importMapRelativePath,
            importMapForBundle: importMapForBundle,
            specifierMap: specifierMap,
            specifierDynamicMap: specifierDynamicMap,
            nativeModulePredicate: nativeModulePredicate,
            entryPointMap: entryPointMap,
            babelPluginMap: babelPluginMap,
            convertMap: convertMap,
            minify: minify,
            logLevel: logLevel,
            writeOnFileSystem: writeOnFileSystem,
            format: format,
            balancerTemplateRelativePath: balancerTemplateRelativePath,
            balancerDataClientPathname: balancerDataClientPathname,
            groupMap: groupMap
          })]));
        });
      });
    });
  }));
  if (!throwUnhandled) return promise;
  return promise.catch(function (e) {
    setTimeout(function () {
      throw e;
    });
  });
};

var generateEntryPointsFolders = _async$g(function (_ref2) {
  var cancellationToken = _ref2.cancellationToken,
      projectPathname = _ref2.projectPathname,
      bundleIntoRelativePath = _ref2.bundleIntoRelativePath,
      importDefaultExtension = _ref2.importDefaultExtension,
      importMapRelativePath = _ref2.importMapRelativePath,
      importMapForBundle = _ref2.importMapForBundle,
      specifierMap = _ref2.specifierMap,
      specifierDynamicMap = _ref2.specifierDynamicMap,
      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$g(function (compileId) {
    return bundleWithBalancing({
      cancellationToken: cancellationToken,
      projectPathname: projectPathname,
      bundleIntoRelativePath: bundleIntoRelativePath,
      importDefaultExtension: importDefaultExtension,
      importMapRelativePath: importMapRelativePath,
      importMapForBundle: importMapForBundle,
      specifierMap: specifierMap,
      specifierDynamicMap: specifierDynamicMap,
      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,
      importDefaultExtension = _ref3.importDefaultExtension,
      importMapRelativePath = _ref3.importMapRelativePath,
      importMapForBundle = _ref3.importMapForBundle,
      specifierMap = _ref3.specifierMap,
      specifierDynamicMap = _ref3.specifierDynamicMap,
      nativeModulePredicate = _ref3.nativeModulePredicate,
      entryPointMap = _ref3.entryPointMap,
      babelPluginMap = _ref3.babelPluginMap,
      convertMap = _ref3.convertMap,
      minify = _ref3.minify,
      logLevel = _ref3.logLevel,
      writeOnFileSystem = _ref3.writeOnFileSystem,
      format = _ref3.format,
      balancerTemplateRelativePath = _ref3.balancerTemplateRelativePath,
      balancerDataClientPathname = _ref3.balancerDataClientPathname,
      groupMap = _ref3.groupMap;
  return Promise.all(Object.keys(entryPointMap).map(_async$g(function (entryPointName) {
    return bundleBalancer({
      cancellationToken: cancellationToken,
      projectPathname: projectPathname,
      bundleIntoRelativePath: bundleIntoRelativePath,
      importDefaultExtension: importDefaultExtension,
      importMapRelativePath: importMapRelativePath,
      importMapForBundle: importMapForBundle,
      specifierMap: specifierMap,
      specifierDynamicMap: specifierDynamicMap,
      nativeModulePredicate: nativeModulePredicate,
      entryPointMap: _defineProperty({}, entryPointName, balancerTemplateRelativePath),
      babelPluginMap: babelPluginMap,
      convertMap: convertMap,
      minify: minify,
      logLevel: logLevel,
      format: format,
      balancerDataClientPathname: balancerDataClientPathname,
      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$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 generateGlobalBundle = _async$h(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,
      globalName = _ref.globalName,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      specifierMap = _ref.specifierMap,
      specifierDynamicMap = _ref.specifierDynamicMap,
      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,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    specifierMap: specifierMap,
    specifierDynamicMap: specifierDynamicMap,
    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$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 generateCommonJsBundle = _async$i(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,
      balancerTemplateRelativePath = _ref.balancerTemplateRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      specifierMap = _ref.specifierMap,
      dynamicSpecifierMap = _ref.dynamicSpecifierMap,
      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,
    defaultBalancerTemplateRelativePath: "/src/bundle-commonjs/commonjs-balancer-template.js",
    balancerDataClientPathname: "/.jsenv/commonjs-balancer-data.js",
    projectPath: projectPath,
    bundleIntoRelativePath: bundleIntoRelativePath,
    cleanBundleInto: cleanBundleInto,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    specifierMap: specifierMap,
    dynamicSpecifierMap: dynamicSpecifierMap,
    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$j(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$j(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,
      balancerTemplateRelativePath = _ref.balancerTemplateRelativePath,
      importDefaultExtension = _ref.importDefaultExtension,
      importMapRelativePath = _ref.importMapRelativePath,
      importMapForBundle = _ref.importMapForBundle,
      specifierMap = _ref.specifierMap,
      dynamicSpecifierMap = _ref.dynamicSpecifierMap,
      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,
    defaultBalancerTemplateRelativePath: "/src/bundle-systemjs/systemjs-balancer-template.js",
    balancerDataClientPathname: "/.jsenv/systemjs-balancer-data.js",
    projectPath: projectPath,
    bundleIntoRelativePath: bundleIntoRelativePath,
    cleanBundleInto: cleanBundleInto,
    importDefaultExtension: importDefaultExtension,
    importMapRelativePath: importMapRelativePath,
    importMapForBundle: importMapForBundle,
    specifierMap: specifierMap,
    dynamicSpecifierMap: dynamicSpecifierMap,
    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,
      relativePathAbstractArray = _ref.relativePathAbstractArray;
  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,
    relativePathAbstractArray: relativePathAbstractArray
  });

  var addDependencyMap = function addDependencyMap(dependencyMap) {
    Object.keys(dependencyMap).forEach(function (relativePath) {
      if (relativePathAbstractArray.includes(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 = _objectSpread2({}, 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,
      relativePathAbstractArray: relativePathAbstractArray
    }); // 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 = _objectSpread2({}, 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,
      relativePathAbstractArray = _ref3.relativePathAbstractArray;
  var dependencyMap = {};
  rollupSourcemap.sources.forEach(function (sourceRelativeToEntry, index) {
    var sourcePath = path.resolve(path.dirname(pathnameToOperatingSystemPath("".concat(projectPathname).concat(entryRelativePath))), sourceRelativeToEntry);
    var sourcePathname = operatingSystemPathToPathname(sourcePath);

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

    var sourceRelativePath = pathnameToRelativePath(sourcePathname, projectPathname);
    var isAbstract = relativePathAbstractArray.includes(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