@atlaspack/core 2.13.2-dev.3682 → 2.14.0

package/lib/requests/AssetRequest.js

@@ -1,132 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = createAssetRequest;
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
-var _AtlaspackConfigRequest = _interopRequireDefault(require("./AtlaspackConfigRequest"));
-var _DevDepRequest = require("./DevDepRequest");
-var _ConfigRequest = require("./ConfigRequest");
-var _projectPath = require("../projectPath");
-var _ReporterRunner = require("../ReporterRunner");
-var _RequestTracker = require("../RequestTracker");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function createAssetRequest(input) {
-  return {
-    type: _RequestTracker.requestTypes.asset_request,
-    id: getId(input),
-    run,
-    input
-  };
-}
-const type = 'asset_request';
-function getId(input) {
-  return (0, _rust().hashString)(type + (0, _projectPath.fromProjectPathRelative)(input.filePath) + input.env.id + String(input.isSource) + String(input.sideEffects) + (input.code ?? '') + ':' + (input.pipeline ?? '') + ':' + (input.query ?? ''));
-}
-async function run({
-  input,
-  api,
-  farm,
-  invalidateReason,
-  options
-}) {
-  (0, _ReporterRunner.report)({
-    type: 'buildProgress',
-    phase: 'transforming',
-    filePath: (0, _projectPath.fromProjectPath)(options.projectRoot, input.filePath)
-  });
-  api.invalidateOnFileUpdate(input.filePath);
-  let start = Date.now();
-  let {
-    optionsRef,
-    ...rest
-  } = input;
-  let {
-    cachePath
-  } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
-  let previousDevDepRequests = new Map(await Promise.all(api.getSubRequests().filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request).map(async req => [req.id, (0, _nullthrows().default)(await api.getRequestResult(req.id))])));
-  let request = {
-    ...rest,
-    invalidateReason,
-    devDeps: new Map([...previousDevDepRequests.entries()].filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
-    invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()].filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {
-      return [{
-        specifier: req.specifier,
-        resolveFrom: req.resolveFrom
-      }, ...(req.additionalInvalidations ?? []).map(i => ({
-        specifier: i.specifier,
-        resolveFrom: i.resolveFrom
-      }))];
-    }))
-  };
-  let {
-    assets,
-    configRequests,
-    error,
-    invalidations,
-    devDepRequests
-  } = await farm.createHandle('runTransform', input.isSingleChangeRebuild)({
-    configCachePath: cachePath,
-    optionsRef,
-    request
-  });
-  let time = Date.now() - start;
-  if (assets) {
-    for (let asset of assets) {
-      asset.stats.time = time;
-    }
-  }
-  for (let filePath of invalidations.invalidateOnFileChange) {
-    api.invalidateOnFileUpdate(filePath);
-    api.invalidateOnFileDelete(filePath);
-  }
-  for (let invalidation of invalidations.invalidateOnFileCreate) {
-    api.invalidateOnFileCreate(invalidation);
-  }
-  for (let env of invalidations.invalidateOnEnvChange) {
-    api.invalidateOnEnvChange(env);
-  }
-  for (let option of invalidations.invalidateOnOptionChange) {
-    api.invalidateOnOptionChange(option);
-  }
-  if (invalidations.invalidateOnStartup) {
-    api.invalidateOnStartup();
-  }
-  if (invalidations.invalidateOnBuild) {
-    api.invalidateOnBuild();
-  }
-  for (let devDepRequest of devDepRequests) {
-    await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
-  }
-  for (let configRequest of configRequests) {
-    await (0, _ConfigRequest.runConfigRequest)(api, configRequest);
-  }
-  if (error != null) {
-    throw new (_diagnostic().default)({
-      diagnostic: error
-    });
-  } else {
-    return (0, _nullthrows().default)(assets);
-  }
-}

package/lib/requests/AtlaspackBuildRequest.js

@@ -1,79 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = createAtlaspackBuildRequest;
-var _BundleGraphRequest = _interopRequireDefault(require("./BundleGraphRequest"));
-var _WriteBundlesRequest = _interopRequireDefault(require("./WriteBundlesRequest"));
-var _utils = require("../utils");
-var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
-var _BundleGraph = require("../BundleGraph");
-var _ReporterRunner = require("../ReporterRunner");
-var _BundleGraph2 = _interopRequireDefault(require("../public/BundleGraph"));
-var _Bundle = require("../public/Bundle");
-var _Asset = require("../public/Asset");
-function _profiler() {
-  const data = require("@atlaspack/profiler");
-  _profiler = function () {
-    return data;
-  };
-  return data;
-}
-var _RequestTracker = require("../RequestTracker");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function createAtlaspackBuildRequest(input) {
-  return {
-    type: _RequestTracker.requestTypes.atlaspack_build_request,
-    id: 'atlaspack_build_request',
-    run,
-    input
-  };
-}
-async function run({
-  input,
-  api,
-  options,
-  rustAtlaspack
-}) {
-  let {
-    optionsRef,
-    requestedAssetIds,
-    signal
-  } = input;
-  let bundleGraphRequest = (0, _BundleGraphRequest.default)({
-    optionsRef,
-    requestedAssetIds,
-    signal
-  });
-  let {
-    bundleGraph,
-    changedAssets,
-    assetRequests
-  } = await api.runRequest(bundleGraphRequest, {
-    force: Boolean(rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
-  });
-
-  // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381 (Windows only)
-  (0, _dumpGraphToGraphViz.default)(bundleGraph._graph, 'BundleGraph', _BundleGraph.bundleGraphEdgeTypes);
-  await (0, _ReporterRunner.report)({
-    type: 'buildProgress',
-    phase: 'bundled',
-    bundleGraph: new _BundleGraph2.default(bundleGraph, (bundle, bundleGraph, options) => _Bundle.NamedBundle.get(bundle, bundleGraph, options), options),
-    changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [id, (0, _Asset.assetFromValue)(asset, options)]))
-  });
-  let packagingMeasurement = _profiler().tracer.createMeasurement('packaging');
-  let writeBundlesRequest = (0, _WriteBundlesRequest.default)({
-    bundleGraph,
-    optionsRef
-  });
-  let bundleInfo = await api.runRequest(writeBundlesRequest);
-  packagingMeasurement && packagingMeasurement.end();
-  (0, _utils.assertSignalNotAborted)(signal);
-  return {
-    bundleGraph,
-    bundleInfo,
-    changedAssets,
-    assetRequests
-  };
-}

package/lib/requests/AtlaspackConfigRequest.js

@@ -1,479 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.create = create;
-exports.default = createAtlaspackConfigRequest;
-exports.getCachedAtlaspackConfig = getCachedAtlaspackConfig;
-exports.getResolveFrom = getResolveFrom;
-exports.loadAtlaspackConfig = loadAtlaspackConfig;
-exports.mergeConfigs = mergeConfigs;
-exports.mergeMaps = mergeMaps;
-exports.mergePipelines = mergePipelines;
-exports.parseAndProcessConfig = parseAndProcessConfig;
-exports.processConfig = processConfig;
-exports.processConfigChain = processConfigChain;
-exports.resolveAtlaspackConfig = resolveAtlaspackConfig;
-exports.resolveExtends = resolveExtends;
-exports.validateConfigFile = validateConfigFile;
-exports.validateNotEmpty = validateNotEmpty;
-function _buildCache() {
-  const data = require("@atlaspack/build-cache");
-  _buildCache = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-function _json() {
-  const data = require("json5");
-  _json = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-var _AtlaspackConfig = require("../AtlaspackConfig");
-var _AtlaspackConfig2 = _interopRequireDefault(require("../AtlaspackConfig.schema"));
-var _projectPath = require("../projectPath");
-var _RequestTracker = require("../RequestTracker");
-var _utils2 = require("../utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const type = 'atlaspack_config_request';
-function createAtlaspackConfigRequest() {
-  return {
-    id: type,
-    type: _RequestTracker.requestTypes[type],
-    async run({
-      api,
-      options
-    }) {
-      let {
-        config,
-        extendedFiles,
-        usedDefault
-      } = await loadAtlaspackConfig((0, _utils2.optionsProxy)(options, api.invalidateOnOptionChange));
-      api.invalidateOnFileUpdate(config.filePath);
-      api.invalidateOnFileDelete(config.filePath);
-      for (let filePath of extendedFiles) {
-        let pp = (0, _projectPath.toProjectPath)(options.projectRoot, filePath);
-        api.invalidateOnFileUpdate(pp);
-        api.invalidateOnFileDelete(pp);
-      }
-      if (usedDefault) {
-        let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
-        api.invalidateOnFileCreate({
-          fileName: '.parcelrc',
-          aboveFilePath: (0, _projectPath.toProjectPath)(options.projectRoot, resolveFrom)
-        });
-      }
-      let cachePath = (0, _utils().hashObject)(config);
-      await options.cache.set(cachePath, config);
-      let result = {
-        config,
-        cachePath
-      };
-      // TODO: don't store config twice (once in the graph and once in a separate cache entry)
-      api.storeResult(result);
-      return result;
-    },
-    input: null
-  };
-}
-const atlaspackConfigCache = (0, _buildCache().createBuildCache)();
-function getCachedAtlaspackConfig(result, options) {
-  let {
-    config: processedConfig,
-    cachePath
-  } = result;
-  let config = atlaspackConfigCache.get(cachePath);
-  if (config) {
-    return config;
-  }
-  config = new _AtlaspackConfig.AtlaspackConfig(processedConfig, options);
-  atlaspackConfigCache.set(cachePath, config);
-  return config;
-}
-async function loadAtlaspackConfig(options) {
-  let atlaspackConfig = await resolveAtlaspackConfig(options);
-  if (!atlaspackConfig) {
-    throw new Error('Could not find a .parcelrc');
-  }
-  return atlaspackConfig;
-}
-async function resolveAtlaspackConfig(options) {
-  let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
-  let configPath = options.config != null ? (await options.packageManager.resolve(options.config, resolveFrom)).resolved : await (0, _utils().resolveConfig)(options.inputFS, resolveFrom, ['.parcelrc'], options.projectRoot);
-  let usedDefault = false;
-  if (configPath == null && options.defaultConfig != null) {
-    usedDefault = true;
-    configPath = (await options.packageManager.resolve(options.defaultConfig, resolveFrom)).resolved;
-  }
-  if (configPath == null) {
-    return null;
-  }
-  let contents;
-  try {
-    contents = await options.inputFS.readFile(configPath, 'utf8');
-  } catch (e) {
-    throw new (_diagnostic().default)({
-      diagnostic: {
-        message: (0, _diagnostic().md)`Could not find parcel config at ${_path().default.relative(options.projectRoot, configPath)}`,
-        origin: '@atlaspack/core'
-      }
-    });
-  }
-  let {
-    config,
-    extendedFiles
-  } = await parseAndProcessConfig(configPath, contents, options);
-  if (options.additionalReporters.length > 0) {
-    config.reporters = [...options.additionalReporters.map(({
-      packageName,
-      resolveFrom
-    }) => ({
-      packageName,
-      resolveFrom
-    })), ...(config.reporters ?? [])];
-  }
-  return {
-    config,
-    extendedFiles,
-    usedDefault
-  };
-}
-function create(config, options) {
-  return processConfigChain(config, config.filePath, options);
-}
-
-// eslint-disable-next-line require-await
-async function parseAndProcessConfig(configPath, contents, options) {
-  let config;
-  try {
-    config = (0, _json().parse)(contents);
-  } catch (e) {
-    let pos = {
-      line: e.lineNumber,
-      column: e.columnNumber
-    };
-    throw new (_diagnostic().default)({
-      diagnostic: {
-        message: `Failed to parse .parcelrc`,
-        origin: '@atlaspack/core',
-        codeFrames: [{
-          filePath: configPath,
-          language: 'json5',
-          code: contents,
-          codeHighlights: [{
-            start: pos,
-            end: pos,
-            message: (0, _diagnostic().escapeMarkdown)(e.message)
-          }]
-        }]
-      }
-    });
-  }
-  return processConfigChain(config, configPath, options);
-}
-function processPipeline(options, pipeline, keyPath, filePath) {
-  if (pipeline) {
-    return pipeline.map((pkg, i) => {
-      // $FlowFixMe
-      if (pkg === '...') return pkg;
-      return {
-        packageName: pkg,
-        resolveFrom: (0, _projectPath.toProjectPath)(options.projectRoot, filePath),
-        keyPath: `${keyPath}/${i}`
-      };
-    });
-  }
-}
-const RESERVED_PIPELINES = new Set(['node:', 'npm:', 'http:', 'https:', 'data:', 'tel:', 'mailto:']);
-async function processMap(
-// $FlowFixMe
-map, keyPath, filePath, options
-// $FlowFixMe
-) {
-  if (!map) return undefined;
-
-  // $FlowFixMe
-  let res = {};
-  for (let k in map) {
-    let i = k.indexOf(':');
-    if (i > 0 && RESERVED_PIPELINES.has(k.slice(0, i + 1))) {
-      let code = await options.inputFS.readFile(filePath, 'utf8');
-      throw new (_diagnostic().default)({
-        diagnostic: {
-          message: `Named pipeline '${k.slice(0, i + 1)}' is reserved.`,
-          origin: '@atlaspack/core',
-          codeFrames: [{
-            filePath: filePath,
-            language: 'json5',
-            code,
-            codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(code, [{
-              key: `${keyPath}/${k}`,
-              type: 'key'
-            }])
-          }],
-          documentationURL: 'https://parceljs.org/features/dependency-resolution/#url-schemes'
-        }
-      });
-    }
-    if (typeof map[k] === 'string') {
-      res[k] = {
-        packageName: map[k],
-        resolveFrom: (0, _projectPath.toProjectPath)(options.projectRoot, filePath),
-        keyPath: `${keyPath}/${k}`
-      };
-    } else {
-      res[k] = processPipeline(options, map[k], `${keyPath}/${k}`, filePath);
-    }
-  }
-  return res;
-}
-async function processConfig(configFile, options) {
-  return {
-    filePath: (0, _projectPath.toProjectPath)(options.projectRoot, configFile.filePath),
-    ...(configFile.resolveFrom != null ? {
-      resolveFrom: (0, _projectPath.toProjectPath)(options.projectRoot, configFile.resolveFrom)
-    } : {
-      /*::...null*/
-    }),
-    resolvers: processPipeline(options, configFile.resolvers, '/resolvers', configFile.filePath),
-    transformers: await processMap(configFile.transformers, '/transformers', configFile.filePath, options),
-    bundler: configFile.bundler != null ? {
-      packageName: configFile.bundler,
-      resolveFrom: (0, _projectPath.toProjectPath)(options.projectRoot, configFile.filePath),
-      keyPath: '/bundler'
-    } : undefined,
-    namers: processPipeline(options, configFile.namers, '/namers', configFile.filePath),
-    runtimes: processPipeline(options, configFile.runtimes, '/runtimes', configFile.filePath),
-    packagers: await processMap(configFile.packagers, '/packagers', configFile.filePath, options),
-    optimizers: await processMap(configFile.optimizers, '/optimizers', configFile.filePath, options),
-    compressors: await processMap(configFile.compressors, '/compressors', configFile.filePath, options),
-    reporters: processPipeline(options, configFile.reporters, '/reporters', configFile.filePath),
-    validators: await processMap(configFile.validators, '/validators', configFile.filePath, options)
-  };
-}
-async function processConfigChain(configFile, filePath, options) {
-  // Validate config...
-  let relativePath = _path().default.relative(options.inputFS.cwd(), filePath);
-  validateConfigFile(configFile, relativePath);
-
-  // Process config...
-  let config = await processConfig({
-    filePath,
-    ...configFile
-  }, options);
-  let extendedFiles = [];
-  if (configFile.extends != null) {
-    let exts = Array.isArray(configFile.extends) ? configFile.extends : [configFile.extends];
-    let errors = [];
-    if (exts.length !== 0) {
-      let extStartConfig;
-      let i = 0;
-      for (let ext of exts) {
-        try {
-          let key = Array.isArray(configFile.extends) ? `/extends/${i}` : '/extends';
-          let resolved = await resolveExtends(ext, filePath, key, options);
-          extendedFiles.push(resolved);
-          let {
-            extendedFiles: moreExtendedFiles,
-            config: nextConfig
-          } = await processExtendedConfig(filePath, key, ext, resolved, options);
-          extendedFiles = extendedFiles.concat(moreExtendedFiles);
-          extStartConfig = extStartConfig ? mergeConfigs(extStartConfig, nextConfig) : nextConfig;
-        } catch (err) {
-          errors.push(err);
-        }
-        i++;
-      }
-
-      // Merge with the inline config last
-      if (extStartConfig) {
-        config = mergeConfigs(extStartConfig, config);
-      }
-    }
-    if (errors.length > 0) {
-      throw new (_diagnostic().default)({
-        diagnostic: errors.flatMap(e => e.diagnostics ?? (0, _diagnostic().errorToDiagnostic)(e))
-      });
-    }
-  }
-  return {
-    config,
-    extendedFiles
-  };
-}
-async function resolveExtends(ext, configPath, extendsKey, options) {
-  if (ext.startsWith('.')) {
-    return _path().default.resolve(_path().default.dirname(configPath), ext);
-  } else {
-    try {
-      let {
-        resolved
-      } = await options.packageManager.resolve(ext, configPath);
-      return options.inputFS.realpath(resolved);
-    } catch (err) {
-      let parentContents = await options.inputFS.readFile(configPath, 'utf8');
-      let alternatives = await (0, _utils().findAlternativeNodeModules)(options.inputFS, ext, _path().default.dirname(configPath));
-      throw new (_diagnostic().default)({
-        diagnostic: {
-          message: `Cannot find extended parcel config`,
-          origin: '@atlaspack/core',
-          codeFrames: [{
-            filePath: configPath,
-            language: 'json5',
-            code: parentContents,
-            codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(parentContents, [{
-              key: extendsKey,
-              type: 'value',
-              message: (0, _diagnostic().md)`Cannot find module "${ext}"${alternatives[0] ? `, did you mean "${alternatives[0]}"?` : ''}`
-            }])
-          }]
-        }
-      });
-    }
-  }
-}
-async function processExtendedConfig(configPath, extendsKey, extendsSpecifier, resolvedExtendedConfigPath, options) {
-  let contents;
-  try {
-    contents = await options.inputFS.readFile(resolvedExtendedConfigPath, 'utf8');
-  } catch (e) {
-    let parentContents = await options.inputFS.readFile(configPath, 'utf8');
-    let alternatives = await (0, _utils().findAlternativeFiles)(options.inputFS, extendsSpecifier, _path().default.dirname(resolvedExtendedConfigPath), options.projectRoot);
-    throw new (_diagnostic().default)({
-      diagnostic: {
-        message: 'Cannot find extended parcel config',
-        origin: '@atlaspack/core',
-        codeFrames: [{
-          filePath: configPath,
-          language: 'json5',
-          code: parentContents,
-          codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(parentContents, [{
-            key: extendsKey,
-            type: 'value',
-            message: (0, _diagnostic().md)`"${extendsSpecifier}" does not exist${alternatives[0] ? `, did you mean "${alternatives[0]}"?` : ''}`
-          }])
-        }]
-      }
-    });
-  }
-  return parseAndProcessConfig(resolvedExtendedConfigPath, contents, options);
-}
-function validateConfigFile(config, relativePath) {
-  try {
-    validateNotEmpty(config, relativePath);
-  } catch (e) {
-    throw new (_diagnostic().default)({
-      diagnostic: {
-        message: e.message,
-        origin: '@atlaspack/core'
-      }
-    });
-  }
-  _utils().validateSchema.diagnostic(_AtlaspackConfig2.default, {
-    data: config,
-    filePath: relativePath
-  }, '@atlaspack/core', 'Invalid Parcel Config');
-}
-function validateNotEmpty(config, relativePath) {
-  _assert().default.notDeepStrictEqual(config, {}, `${relativePath} can't be empty`);
-}
-function mergeConfigs(base, ext) {
-  return {
-    filePath: ext.filePath,
-    resolvers: assertPurePipeline(mergePipelines(base.resolvers, ext.resolvers)),
-    transformers: mergeMaps(base.transformers, ext.transformers, mergePipelines),
-    validators: mergeMaps(base.validators, ext.validators, mergePipelines),
-    bundler: ext.bundler || base.bundler,
-    namers: assertPurePipeline(mergePipelines(base.namers, ext.namers)),
-    runtimes: assertPurePipeline(mergePipelines(base.runtimes, ext.runtimes)),
-    packagers: mergeMaps(base.packagers, ext.packagers),
-    optimizers: mergeMaps(base.optimizers, ext.optimizers, mergePipelines),
-    compressors: mergeMaps(base.compressors, ext.compressors, mergePipelines),
-    reporters: assertPurePipeline(mergePipelines(base.reporters, ext.reporters))
-  };
-}
-function getResolveFrom(fs, projectRoot) {
-  let cwd = fs.cwd();
-  let dir = (0, _utils().isDirectoryInside)(cwd, projectRoot) ? cwd : projectRoot;
-  return _path().default.join(dir, 'index');
-}
-function assertPurePipeline(pipeline) {
-  return pipeline.map(s => {
-    (0, _assert().default)(typeof s !== 'string');
-    return s;
-  });
-}
-function mergePipelines(base, ext) {
-  if (ext == null) {
-    return base ?? [];
-  }
-  if (ext.filter(v => v === '...').length > 1) {
-    throw new Error('Only one spread element can be included in a config pipeline');
-  }
-
-  // Merge the base pipeline if a rest element is defined
-  let spreadIndex = ext.indexOf('...');
-  if (spreadIndex >= 0) {
-    return [...ext.slice(0, spreadIndex), ...(base ?? []), ...ext.slice(spreadIndex + 1)];
-  } else {
-    return ext;
-  }
-}
-function mergeMaps(base, ext, merger) {
-  if (!ext || Object.keys(ext).length === 0) {
-    return base || {};
-  }
-  if (!base) {
-    return ext;
-  }
-  let res = {};
-  // Add the extension options first so they have higher precedence in the output glob map
-  for (let k in ext) {
-    //$FlowFixMe Flow doesn't correctly infer the type. See https://github.com/facebook/flow/issues/1736.
-    let key = k;
-    res[key] = merger && base[key] != null ? merger(base[key], ext[key]) : ext[key];
-  }
-
-  // Add base options that aren't defined in the extension
-  for (let k in base) {
-    // $FlowFixMe
-    let key = k;
-    if (res[key] == null) {
-      res[key] = base[key];
-    }
-  }
-  return res;
-}