@atlaspack/core 2.13.2-dev.3689 → 2.14.0

package/lib/public/BundleGraph.js

@@ -1,279 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.bundleGraphToInternalBundleGraph = bundleGraphToInternalBundleGraph;
-exports.default = void 0;
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-function _graph() {
-  const data = require("@atlaspack/graph");
-  _graph = function () {
-    return data;
-  };
-  return data;
-}
-var _Asset = require("./Asset");
-var _Bundle = require("./Bundle");
-var _Dependency = _interopRequireWildcard(require("./Dependency"));
-var _Target = require("./Target");
-var _utils = require("../utils");
-var _BundleGroup = _interopRequireWildcard(require("./BundleGroup"));
-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; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// Friendly access for other modules within this package that need access
-// to the internal bundle.
-const _bundleGraphToInternalBundleGraph = new WeakMap();
-function bundleGraphToInternalBundleGraph(bundleGraph) {
-  return (0, _nullthrows().default)(_bundleGraphToInternalBundleGraph.get(bundleGraph));
-}
-class BundleGraph {
-  #graph;
-  #options;
-  #createBundle;
-  constructor(graph, createBundle, options) {
-    this.#graph = graph;
-    this.#options = options;
-    this.#createBundle = createBundle;
-    // $FlowFixMe
-    _bundleGraphToInternalBundleGraph.set(this, graph);
-  }
-  getAssetById(id) {
-    return (0, _Asset.assetFromValue)(this.#graph.getAssetById(id), this.#options);
-  }
-  getAssetPublicId(asset) {
-    return this.#graph.getAssetPublicId((0, _Asset.assetToAssetValue)(asset));
-  }
-  isDependencySkipped(dep) {
-    return this.#graph.isDependencySkipped((0, _Dependency.dependencyToInternalDependency)(dep));
-  }
-  getResolvedAsset(dep, bundle) {
-    let resolution = this.#graph.getResolvedAsset((0, _Dependency.dependencyToInternalDependency)(dep), bundle && (0, _Bundle.bundleToInternalBundle)(bundle));
-    if (resolution) {
-      return (0, _Asset.assetFromValue)(resolution, this.#options);
-    }
-  }
-  getIncomingDependencies(asset) {
-    return this.#graph.getIncomingDependencies((0, _Asset.assetToAssetValue)(asset)).map(dep => (0, _Dependency.getPublicDependency)(dep, this.#options));
-  }
-  getAssetWithDependency(dep) {
-    let asset = this.#graph.getAssetWithDependency((0, _Dependency.dependencyToInternalDependency)(dep));
-    if (asset) {
-      return (0, _Asset.assetFromValue)(asset, this.#options);
-    }
-  }
-  getBundleGroupsContainingBundle(bundle) {
-    return this.#graph.getBundleGroupsContainingBundle((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundleGroup => new _BundleGroup.default(bundleGroup, this.#options));
-  }
-  getReferencedBundles(bundle, opts) {
-    return this.#graph.getReferencedBundles((0, _Bundle.bundleToInternalBundle)(bundle), opts).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
-  }
-  getReferencingBundles(bundle) {
-    return this.#graph.getReferencingBundles((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
-  }
-  resolveAsyncDependency(dependency, bundle) {
-    let resolved = this.#graph.resolveAsyncDependency((0, _Dependency.dependencyToInternalDependency)(dependency), bundle && (0, _Bundle.bundleToInternalBundle)(bundle));
-    if (resolved == null) {
-      return;
-    } else if (resolved.type === 'bundle_group') {
-      return {
-        type: 'bundle_group',
-        value: new _BundleGroup.default(resolved.value, this.#options)
-      };
-    }
-    return {
-      type: 'asset',
-      value: (0, _Asset.assetFromValue)(resolved.value, this.#options)
-    };
-  }
-  getReferencedBundle(dependency, bundle) {
-    let result = this.#graph.getReferencedBundle((0, _Dependency.dependencyToInternalDependency)(dependency), (0, _Bundle.bundleToInternalBundle)(bundle));
-    if (result != null) {
-      return this.#createBundle(result, this.#graph, this.#options);
-    }
-  }
-  getDependencies(asset) {
-    return this.#graph.getDependencies((0, _Asset.assetToAssetValue)(asset)).map(dep => (0, _Dependency.getPublicDependency)(dep, this.#options));
-  }
-  isAssetReachableFromBundle(asset, bundle) {
-    return this.#graph.isAssetReachableFromBundle((0, _Asset.assetToAssetValue)(asset), (0, _Bundle.bundleToInternalBundle)(bundle));
-  }
-  isAssetReferenced(bundle, asset) {
-    return this.#graph.isAssetReferenced((0, _Bundle.bundleToInternalBundle)(bundle), (0, _Asset.assetToAssetValue)(asset));
-  }
-  hasParentBundleOfType(bundle, type) {
-    return this.#graph.hasParentBundleOfType((0, _Bundle.bundleToInternalBundle)(bundle), type);
-  }
-  getBundlesInBundleGroup(bundleGroup, opts) {
-    return this.#graph.getBundlesInBundleGroup((0, _BundleGroup.bundleGroupToInternalBundleGroup)(bundleGroup), opts).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
-  }
-  getBundles(opts) {
-    return this.#graph.getBundles(opts).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
-  }
-  isEntryBundleGroup(bundleGroup) {
-    return this.#graph.isEntryBundleGroup((0, _BundleGroup.bundleGroupToInternalBundleGroup)(bundleGroup));
-  }
-  getChildBundles(bundle) {
-    return this.#graph.getChildBundles((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
-  }
-  getParentBundles(bundle) {
-    return this.#graph.getParentBundles((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
-  }
-  getSymbolResolution(asset, symbol, boundary) {
-    let res = this.#graph.getSymbolResolution((0, _Asset.assetToAssetValue)(asset), symbol, boundary ? (0, _Bundle.bundleToInternalBundle)(boundary) : null);
-    return {
-      asset: (0, _Asset.assetFromValue)(res.asset, this.#options),
-      exportSymbol: res.exportSymbol,
-      symbol: res.symbol,
-      loc: (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, res.loc)
-    };
-  }
-  getExportedSymbols(asset, boundary) {
-    let res = this.#graph.getExportedSymbols((0, _Asset.assetToAssetValue)(asset), boundary ? (0, _Bundle.bundleToInternalBundle)(boundary) : null);
-    return res.map(e => ({
-      asset: (0, _Asset.assetFromValue)(e.asset, this.#options),
-      exportSymbol: e.exportSymbol,
-      symbol: e.symbol,
-      loc: (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, e.loc),
-      exportAs: e.exportAs
-    }));
-  }
-  traverse(visit, start, opts) {
-    return this.#graph.traverse((0, _graph().mapVisitor)((node, actions) => {
-      // Skipping unused dependencies here is faster than doing an isDependencySkipped check inside the visitor
-      // because the node needs to be re-looked up by id from the hashmap.
-      if (opts !== null && opts !== void 0 && opts.skipUnusedDependencies && node.type === 'dependency' && (node.hasDeferred || node.excluded)) {
-        actions.skipChildren();
-        return null;
-      }
-      return node.type === 'asset' ? {
-        type: 'asset',
-        value: (0, _Asset.assetFromValue)(node.value, this.#options)
-      } : {
-        type: 'dependency',
-        value: (0, _Dependency.getPublicDependency)(node.value, this.#options)
-      };
-    }, visit), start ? (0, _Asset.assetToAssetValue)(start) : undefined);
-  }
-  traverseBundles(visit, startBundle) {
-    return this.#graph.traverseBundles((0, _graph().mapVisitor)(bundle => this.#createBundle(bundle, this.#graph, this.#options), visit), startBundle == null ? undefined : (0, _Bundle.bundleToInternalBundle)(startBundle));
-  }
-  getBundlesWithAsset(asset) {
-    return this.#graph.getBundlesWithAsset((0, _Asset.assetToAssetValue)(asset)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
-  }
-  getBundlesWithDependency(dependency) {
-    return this.#graph.getBundlesWithDependency((0, _Dependency.dependencyToInternalDependency)(dependency)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
-  }
-  getUsedSymbols(v) {
-    if (v instanceof _Asset.Asset) {
-      return this.#graph.getUsedSymbolsAsset((0, _Asset.assetToAssetValue)(v));
-    } else {
-      (0, _assert().default)(v instanceof _Dependency.default);
-      return this.#graph.getUsedSymbolsDependency((0, _Dependency.dependencyToInternalDependency)(v));
-    }
-  }
-  getEntryRoot(target) {
-    return this.#graph.getEntryRoot(this.#options.projectRoot, (0, _Target.targetToInternalTarget)(target));
-  }
-
-  // Given a set of dependencies, return any conditions where those dependencies are either
-  // the true or false dependency for those conditions. This is currently used to work out which
-  // conditions belong to a bundle in packaging.
-  getConditionsForDependencies(deps, bundle) {
-    const conditions = new Set();
-    const depIds = deps.map(dep => dep.id);
-    for (const condition of this.#graph._conditions.values()) {
-      if (depIds.includes(condition.ifTrueDependency.id) || depIds.includes(condition.ifFalseDependency.id)) {
-        const [[trueAsset, ifTrueBundles], [falseAsset, ifFalseBundles]] = [condition.ifTrueDependency, condition.ifFalseDependency].map(dep => {
-          const asset = this.#graph.getResolvedAsset(dep, (0, _Bundle.bundleToInternalBundle)(bundle));
-          if (asset && this.#graph.bundleHasAsset((0, _Bundle.bundleToInternalBundle)(bundle), asset)) {
-            // Asset is in the same bundle, we know it doesn't need to be loaded externally
-            return [asset, []];
-          }
-          const resolvedAsync = this.#graph.resolveAsyncDependency(dep, (0, _Bundle.bundleToInternalBundle)(bundle));
-          if ((resolvedAsync === null || resolvedAsync === void 0 ? void 0 : resolvedAsync.type) === 'asset') {
-            // Single bundle to load dynamically
-            return [resolvedAsync.value, [this.#createBundle((0, _nullthrows().default)(this.#graph.getReferencedBundle(dep, (0, _Bundle.bundleToInternalBundle)(bundle)), `Failed to load referenced bundle for '${dep.specifier}' specifier from '${String(dep.sourcePath)}'`), this.#graph, this.#options)]];
-          } else if (resolvedAsync) {
-            // Bundle group means we have multiple bundles to load first
-            return [this.#graph.getAssetById(resolvedAsync.value.entryAssetId), this.#graph.getBundlesInBundleGroup(resolvedAsync.value).map(b => this.#createBundle(b, this.#graph, this.#options))];
-          } else {
-            return [(0, _nullthrows().default)(asset, `Failed to load depenendency for '${dep.specifier}' specifier from '${String(dep.sourcePath)}'`), []];
-          }
-        });
-        conditions.add({
-          publicId: condition.publicId,
-          key: condition.key,
-          ifTrueDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifTrueDependency.id), 'ifTrueDependency was null'),
-          ifFalseDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifFalseDependency.id), 'ifFalseDependency was null'),
-          ifTrueBundles,
-          ifFalseBundles,
-          ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
-          ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset)
-        });
-      }
-    }
-    return conditions;
-  }
-
-  // This is used to generate information for building a manifest that can
-  // be used by a webserver to understand which conditions are used by which bundles,
-  // and which bundles those conditions require depending on what they evaluate to.
-  getConditionalBundleMapping() {
-    let bundleConditions = new Map();
-
-    // Convert the internal references in conditions to public API references
-    for (const cond of this.#graph._conditions.values()) {
-      let assets = Array.from(cond.assets).map(asset => (0, _nullthrows().default)(this.getAssetById(asset.id)));
-      let bundles = new Set();
-      let ifTrueBundles = [];
-      let ifFalseBundles = [];
-      for (const asset of assets) {
-        const bundlesWithAsset = this.getBundlesWithAsset(asset);
-        for (const bundle of bundlesWithAsset) {
-          bundles.add(bundle);
-        }
-        const assetDeps = this.getDependencies(asset);
-        const depToBundles = dep => {
-          const publicDep = (0, _nullthrows().default)(assetDeps.find(assetDep => dep.id === assetDep.id));
-          const resolved = this.resolveAsyncDependency(publicDep);
-          if (!resolved) {
-            // If there's no async dependency, don't list it as required
-            return [];
-          }
-          (0, _assert().default)(resolved.type === 'bundle_group');
-          return this.getBundlesInBundleGroup(resolved.value);
-        };
-        ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
-        ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
-      }
-      for (let bundle of bundles) {
-        const conditions = bundleConditions.get(bundle) ?? new Map();
-        conditions.set(cond.key, {
-          ifTrueBundles,
-          ifFalseBundles
-        });
-        bundleConditions.set(bundle, conditions);
-      }
-    }
-    return bundleConditions;
-  }
-  getReferencedConditionalBundles(bundle) {
-    return this.#graph.getReferencedConditionalBundles((0, _Bundle.bundleToInternalBundle)(bundle)).map(result => this.#createBundle(result, this.#graph, this.#options));
-  }
-}
-exports.default = BundleGraph;

package/lib/public/BundleGroup.js

@@ -1,50 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.bundleGroupToInternalBundleGroup = bundleGroupToInternalBundleGroup;
-exports.default = void 0;
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-var _Target = _interopRequireDefault(require("./Target"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const internalBundleGroupToBundleGroup = new WeakMap();
-const _bundleGroupToInternalBundleGroup = new WeakMap();
-function bundleGroupToInternalBundleGroup(target) {
-  return (0, _nullthrows().default)(_bundleGroupToInternalBundleGroup.get(target));
-}
-const inspect = Symbol.for('nodejs.util.inspect.custom');
-class BundleGroup {
-  #bundleGroup /*: InternalBundleGroup */;
-  #options /*: AtlaspackOptions */;
-
-  constructor(bundleGroup, options) {
-    let existing = internalBundleGroupToBundleGroup.get(bundleGroup);
-    if (existing != null) {
-      return existing;
-    }
-    this.#bundleGroup = bundleGroup;
-    this.#options = options;
-    _bundleGroupToInternalBundleGroup.set(this, bundleGroup);
-    internalBundleGroupToBundleGroup.set(bundleGroup, this);
-    return this;
-  }
-  get target() {
-    return new _Target.default(this.#bundleGroup.target, this.#options);
-  }
-  get entryAssetId() {
-    return this.#bundleGroup.entryAssetId;
-  }
-
-  // $FlowFixMe
-  [inspect]() {
-    return `BundleGroup(${this.entryAssetId})`;
-  }
-}
-exports.default = BundleGroup;

package/lib/public/Config.js

@@ -1,202 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-var _Environment = _interopRequireDefault(require("./Environment"));
-var _projectPath = require("../projectPath");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const internalConfigToConfig = new (_utils().DefaultWeakMap)(() => new WeakMap());
-class PublicConfig {
-  #config /*: Config */;
-  #pkg /*: ?PackageJSON */;
-  #pkgFilePath /*: ?FilePath */;
-  #options /*: AtlaspackOptions */;
-
-  constructor(config, options) {
-    let existing = internalConfigToConfig.get(options).get(config);
-    if (existing != null) {
-      return existing;
-    }
-    this.#config = config;
-    this.#options = options;
-    internalConfigToConfig.get(options).set(config, this);
-    return this;
-  }
-  get env() {
-    return new _Environment.default(this.#config.env, this.#options);
-  }
-  get searchPath() {
-    return (0, _projectPath.fromProjectPath)(this.#options.projectRoot, this.#config.searchPath);
-  }
-  get result() {
-    return this.#config.result;
-  }
-  get isSource() {
-    return this.#config.isSource;
-  }
-
-  // $FlowFixMe
-  setResult(result) {
-    this.#config.result = result;
-  }
-  setCacheKey(cacheKey) {
-    this.#config.cacheKey = cacheKey;
-  }
-  invalidateOnFileChange(filePath) {
-    this.#config.invalidateOnFileChange.add((0, _projectPath.toProjectPath)(this.#options.projectRoot, filePath));
-  }
-  invalidateOnConfigKeyChange(filePath, configKey) {
-    this.#config.invalidateOnConfigKeyChange.push({
-      filePath: (0, _projectPath.toProjectPath)(this.#options.projectRoot, filePath),
-      configKey
-    });
-  }
-  addDevDependency(devDep) {
-    var _devDep$additionalInv;
-    this.#config.devDeps.push({
-      ...devDep,
-      resolveFrom: (0, _projectPath.toProjectPath)(this.#options.projectRoot, devDep.resolveFrom),
-      additionalInvalidations: (_devDep$additionalInv = devDep.additionalInvalidations) === null || _devDep$additionalInv === void 0 ? void 0 : _devDep$additionalInv.map(i => ({
-        ...i,
-        resolveFrom: (0, _projectPath.toProjectPath)(this.#options.projectRoot, i.resolveFrom)
-      }))
-    });
-  }
-  invalidateOnFileCreate(invalidation) {
-    if (invalidation.glob != null) {
-      // $FlowFixMe
-      this.#config.invalidateOnFileCreate.push(invalidation);
-    } else if (invalidation.filePath != null) {
-      this.#config.invalidateOnFileCreate.push({
-        filePath: (0, _projectPath.toProjectPath)(this.#options.projectRoot, invalidation.filePath)
-      });
-    } else {
-      (0, _assert().default)(invalidation.aboveFilePath != null);
-      this.#config.invalidateOnFileCreate.push({
-        // $FlowFixMe
-        fileName: invalidation.fileName,
-        aboveFilePath: (0, _projectPath.toProjectPath)(this.#options.projectRoot, invalidation.aboveFilePath)
-      });
-    }
-  }
-  invalidateOnEnvChange(env) {
-    this.#config.invalidateOnEnvChange.add(env);
-  }
-  invalidateOnStartup() {
-    this.#config.invalidateOnStartup = true;
-  }
-  invalidateOnBuild() {
-    this.#config.invalidateOnBuild = true;
-  }
-  async getConfigFrom(searchPath, fileNames, options) {
-    let packageKey = options === null || options === void 0 ? void 0 : options.packageKey;
-    if (packageKey != null) {
-      let pkg = await this.getConfigFrom(searchPath, ['package.json'], {
-        exclude: true
-      });
-      if (pkg && pkg.contents[packageKey]) {
-        // Invalidate only when the package key changes
-        this.invalidateOnConfigKeyChange(pkg.filePath, packageKey);
-        return {
-          contents: pkg.contents[packageKey],
-          filePath: pkg.filePath
-        };
-      }
-    }
-    if (fileNames.length === 0) {
-      return null;
-    }
-
-    // Invalidate when any of the file names are created above the search path.
-    for (let fileName of fileNames) {
-      this.invalidateOnFileCreate({
-        fileName,
-        aboveFilePath: searchPath
-      });
-    }
-    let parse = options && options.parse;
-    let configFilePath = await (0, _utils().resolveConfig)(this.#options.inputFS, searchPath, fileNames, this.#options.projectRoot);
-    if (configFilePath == null) {
-      return null;
-    }
-    if (!options || !options.exclude) {
-      this.invalidateOnFileChange(configFilePath);
-    }
-
-    // If this is a JavaScript file, load it with the package manager.
-    let extname = _path().default.extname(configFilePath);
-    if (extname === '.js' || extname === '.cjs' || extname === '.mjs') {
-      let specifier = (0, _utils().relativePath)(_path().default.dirname(searchPath), configFilePath);
-
-      // Add dev dependency so we reload the config and any dependencies in watch mode.
-      this.addDevDependency({
-        specifier,
-        resolveFrom: searchPath
-      });
-
-      // Invalidate on startup in case the config is non-deterministic,
-      // e.g. uses unknown environment variables, reads from the filesystem, etc.
-      this.invalidateOnStartup();
-      let config = await this.#options.packageManager.require(specifier, searchPath);
-      if (
-      // $FlowFixMe
-      Object.prototype.toString.call(config) === '[object Module]' && config.default != null) {
-        // Native ESM config. Try to use a default export, otherwise fall back to the whole namespace.
-        config = config.default;
-      }
-      return {
-        contents: config,
-        filePath: configFilePath
-      };
-    }
-    let conf = await (0, _utils().readConfig)(this.#options.inputFS, configFilePath, parse == null ? null : {
-      parse
-    });
-    if (conf == null) {
-      return null;
-    }
-    return {
-      contents: conf.config,
-      filePath: configFilePath
-    };
-  }
-  getConfig(filePaths, options) {
-    return this.getConfigFrom(this.searchPath, filePaths, options);
-  }
-  async getPackage() {
-    if (this.#pkg) {
-      return this.#pkg;
-    }
-    let pkgConfig = await this.getConfig(['package.json']);
-    if (!pkgConfig) {
-      return null;
-    }
-    this.#pkg = pkgConfig.contents;
-    this.#pkgFilePath = pkgConfig.filePath;
-    return this.#pkg;
-  }
-}
-exports.default = PublicConfig;

package/lib/public/Dependency.js

@@ -1,131 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-exports.dependencyToInternalDependency = dependencyToInternalDependency;
-exports.getPublicDependency = getPublicDependency;
-var _types = require("../types");
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-var _Environment = _interopRequireDefault(require("./Environment"));
-var _Target = _interopRequireDefault(require("./Target"));
-var _Symbols = require("./Symbols");
-var _projectPath = require("../projectPath");
-var _utils = require("../utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const SpecifierTypeNames = Object.keys(_types.SpecifierType);
-const PriorityNames = Object.keys(_types.Priority);
-const inspect = Symbol.for('nodejs.util.inspect.custom');
-const internalDependencyToDependency = new WeakMap();
-const _dependencyToInternalDependency = new WeakMap();
-function dependencyToInternalDependency(dependency) {
-  return (0, _nullthrows().default)(_dependencyToInternalDependency.get(dependency));
-}
-function getPublicDependency(dep, options) {
-  let existing = internalDependencyToDependency.get(dep);
-  if (existing != null) {
-    return existing;
-  }
-  return new Dependency(dep, options);
-}
-class Dependency {
-  #dep /*: InternalDependency */;
-  #options /*: AtlaspackOptions */;
-
-  constructor(dep, options) {
-    this.#dep = dep;
-    this.#options = options;
-    _dependencyToInternalDependency.set(this, dep);
-    internalDependencyToDependency.set(dep, this);
-    return this;
-  }
-
-  // $FlowFixMe
-  [inspect]() {
-    return `Dependency(${String(this.sourcePath)} -> ${this.specifier})`;
-  }
-  get id() {
-    return this.#dep.id;
-  }
-  get specifier() {
-    return this.#dep.specifier;
-  }
-  get specifierType() {
-    return SpecifierTypeNames[this.#dep.specifierType];
-  }
-  get priority() {
-    return PriorityNames[this.#dep.priority];
-  }
-  get needsStableName() {
-    return this.#dep.needsStableName;
-  }
-  get bundleBehavior() {
-    let bundleBehavior = this.#dep.bundleBehavior;
-    return bundleBehavior == null ? null : _types.BundleBehaviorNames[bundleBehavior];
-  }
-  get isEntry() {
-    return this.#dep.isEntry;
-  }
-  get isOptional() {
-    return this.#dep.isOptional;
-  }
-  get loc() {
-    return (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, this.#dep.loc);
-  }
-  get env() {
-    return new _Environment.default(this.#dep.env, this.#options);
-  }
-  get packageConditions() {
-    // Merge custom conditions with conditions stored as bitflags.
-    // Order is not important because exports conditions are resolved
-    // in the order they are declared in the package.json.
-    let conditions = this.#dep.customPackageConditions;
-    if (this.#dep.packageConditions) {
-      conditions = conditions ? [...conditions] : [];
-      for (let key in _types.ExportsCondition) {
-        if (this.#dep.packageConditions & _types.ExportsCondition[key]) {
-          conditions.push(key);
-        }
-      }
-    }
-    return conditions;
-  }
-  get meta() {
-    return this.#dep.meta;
-  }
-  get symbols() {
-    return new _Symbols.MutableDependencySymbols(this.#options, this.#dep);
-  }
-  get target() {
-    let target = this.#dep.target;
-    return target ? new _Target.default(target, this.#options) : null;
-  }
-  get sourceAssetId() {
-    // TODO: does this need to be public?
-    return this.#dep.sourceAssetId;
-  }
-  get sourcePath() {
-    // TODO: does this need to be public?
-    return (0, _projectPath.fromProjectPath)(this.#options.projectRoot, this.#dep.sourcePath);
-  }
-  get sourceAssetType() {
-    return this.#dep.sourceAssetType;
-  }
-  get resolveFrom() {
-    return (0, _projectPath.fromProjectPath)(this.#options.projectRoot, this.#dep.resolveFrom ?? this.#dep.sourcePath);
-  }
-  get range() {
-    return this.#dep.range;
-  }
-  get pipeline() {
-    return this.#dep.pipeline;
-  }
-}
-exports.default = Dependency;