@atlaspack/core 2.24.1 → 2.24.2-dev-ts-project-refs-d30e9754f.0

package/dist/public/Asset.js

@@ -0,0 +1,279 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _BaseAsset_asset, _BaseAsset_query, _Asset_asset, _Asset_env, _MutableAsset_asset;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableAsset = exports.Asset = void 0;
+exports.assetToAssetValue = assetToAssetValue;
+exports.mutableAssetToUncommittedAsset = mutableAssetToUncommittedAsset;
+exports.assetFromValue = assetFromValue;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const Environment_1 = __importDefault(require("./Environment"));
+const Dependency_1 = require("./Dependency");
+const Symbols_1 = require("./Symbols");
+const UncommittedAsset_1 = __importDefault(require("../UncommittedAsset"));
+const CommittedAsset_1 = __importDefault(require("../CommittedAsset"));
+const Environment_2 = require("../Environment");
+const projectPath_1 = require("../projectPath");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const uncommittedAssetValueToAsset = new WeakMap();
+const committedAssetValueToAsset = new WeakMap();
+const assetValueToMutableAsset = new WeakMap();
+const _assetToAssetValue = new WeakMap();
+const _mutableAssetToUncommittedAsset = new WeakMap();
+function assetToAssetValue(asset) {
+    return (0, nullthrows_1.default)(_assetToAssetValue.get(asset));
+}
+function mutableAssetToUncommittedAsset(mutableAsset) {
+    return (0, nullthrows_1.default)(_mutableAssetToUncommittedAsset.get(mutableAsset));
+}
+function assetFromValue(value, options) {
+    return new Asset(value.committed
+        ? new CommittedAsset_1.default(value, options)
+        : new UncommittedAsset_1.default({
+            value,
+            options,
+        }));
+}
+class BaseAsset {
+    constructor(asset) {
+        _BaseAsset_asset.set(this, void 0);
+        _BaseAsset_query.set(this, void 0);
+        __classPrivateFieldSet(this, _BaseAsset_asset, asset, "f");
+        _assetToAssetValue.set(this, asset.value);
+    }
+    [(_BaseAsset_asset = new WeakMap(), _BaseAsset_query = new WeakMap(), inspect)]() {
+        return `Asset(${this.filePath})`;
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.id;
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.type;
+    }
+    get env() {
+        return new Environment_1.default((0, EnvironmentManager_1.fromEnvironmentId)(__classPrivateFieldGet(this, _BaseAsset_asset, "f").value.env), __classPrivateFieldGet(this, _BaseAsset_asset, "f").options);
+    }
+    get fs() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").options.inputFS;
+    }
+    get filePath() {
+        return (0, projectPath_1.fromProjectPath)(__classPrivateFieldGet(this, _BaseAsset_asset, "f").options.projectRoot, __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.filePath);
+    }
+    get query() {
+        if (!__classPrivateFieldGet(this, _BaseAsset_query, "f")) {
+            __classPrivateFieldSet(this, _BaseAsset_query, new URLSearchParams(__classPrivateFieldGet(this, _BaseAsset_asset, "f").value.query ?? ''), "f");
+        }
+        return __classPrivateFieldGet(this, _BaseAsset_query, "f");
+    }
+    get meta() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.meta;
+    }
+    get bundleBehavior() {
+        let bundleBehavior = __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.bundleBehavior;
+        return bundleBehavior == null ? null : types_1.BundleBehaviorNames[bundleBehavior];
+    }
+    get isBundleSplittable() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.isBundleSplittable;
+    }
+    get isSource() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.isSource;
+    }
+    get sideEffects() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.sideEffects;
+    }
+    get symbols() {
+        // @ts-expect-error TS2322
+        return new Symbols_1.AssetSymbols(__classPrivateFieldGet(this, _BaseAsset_asset, "f").options, __classPrivateFieldGet(this, _BaseAsset_asset, "f").value);
+    }
+    get uniqueKey() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.uniqueKey;
+    }
+    get astGenerator() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.astGenerator;
+    }
+    get pipeline() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").value.pipeline;
+    }
+    getDependencies() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f")
+            .getDependencies()
+            .map((dep) => (0, Dependency_1.getPublicDependency)(dep, __classPrivateFieldGet(this, _BaseAsset_asset, "f").options));
+    }
+    getCode() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").getCode();
+    }
+    getBuffer() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").getBuffer();
+    }
+    getStream() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").getStream();
+    }
+    getMap() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").getMap();
+    }
+    getAST() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").getAST();
+    }
+    getMapBuffer() {
+        return __classPrivateFieldGet(this, _BaseAsset_asset, "f").getMapBuffer();
+    }
+}
+class Asset extends BaseAsset {
+    constructor(asset) {
+        let assetValueToAsset = asset.value.committed
+            ? committedAssetValueToAsset
+            : uncommittedAssetValueToAsset;
+        let existing = assetValueToAsset.get(asset.value);
+        if (existing != null) {
+            return existing;
+        }
+        super(asset);
+        // @ts-expect-error TS2564
+        _Asset_asset.set(this, void 0);
+        _Asset_env.set(this, void 0);
+        __classPrivateFieldSet(this, _Asset_asset, asset, "f");
+        assetValueToAsset.set(asset.value, this);
+        return this;
+    }
+    get env() {
+        __classPrivateFieldSet(this, _Asset_env, __classPrivateFieldGet(this, _Asset_env, "f") ?? new Environment_1.default((0, EnvironmentManager_1.fromEnvironmentId)(__classPrivateFieldGet(this, _Asset_asset, "f").value.env), __classPrivateFieldGet(this, _Asset_asset, "f").options), "f");
+        return __classPrivateFieldGet(this, _Asset_env, "f");
+    }
+    get stats() {
+        return __classPrivateFieldGet(this, _Asset_asset, "f").value.stats;
+    }
+}
+exports.Asset = Asset;
+_Asset_asset = new WeakMap(), _Asset_env = new WeakMap();
+class MutableAsset extends BaseAsset {
+    constructor(asset) {
+        let existing = assetValueToMutableAsset.get(asset.value);
+        if (existing != null) {
+            return existing;
+        }
+        super(asset);
+        // @ts-expect-error TS2564
+        _MutableAsset_asset.set(this, void 0);
+        __classPrivateFieldSet(this, _MutableAsset_asset, asset, "f");
+        assetValueToMutableAsset.set(asset.value, this);
+        _mutableAssetToUncommittedAsset.set(this, asset);
+        return this;
+    }
+    setMap(map) {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").setMap(map);
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.type;
+    }
+    // @ts-expect-error TS1095
+    set type(type): void {
+        if (type !== __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.type) {
+            __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.type = type;
+            __classPrivateFieldGet(this, _MutableAsset_asset, "f").updateId();
+        }
+    }
+    get bundleBehavior() {
+        let bundleBehavior = __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.bundleBehavior;
+        return bundleBehavior == null ? null : types_1.BundleBehaviorNames[bundleBehavior];
+    }
+    // @ts-expect-error TS1095
+    set bundleBehavior(bundleBehavior): void {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.bundleBehavior = bundleBehavior
+            ? types_1.BundleBehavior[bundleBehavior]
+            : null;
+    }
+    get isBundleSplittable() {
+        return __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.isBundleSplittable;
+    }
+    // @ts-expect-error TS1095
+    set isBundleSplittable(isBundleSplittable): void {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.isBundleSplittable = isBundleSplittable;
+    }
+    get sideEffects() {
+        return __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.sideEffects;
+    }
+    // @ts-expect-error TS1095
+    set sideEffects(sideEffects): void {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.sideEffects = sideEffects;
+    }
+    get uniqueKey() {
+        return __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.uniqueKey;
+    }
+    // @ts-expect-error TS1095
+    set uniqueKey(uniqueKey): void {
+        if (__classPrivateFieldGet(this, _MutableAsset_asset, "f").value.uniqueKey != null) {
+            throw new Error("Cannot change an asset's uniqueKey after it has been set.");
+        }
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.uniqueKey = uniqueKey;
+    }
+    get symbols() {
+        // @ts-expect-error TS2322
+        return new Symbols_1.MutableAssetSymbols(__classPrivateFieldGet(this, _MutableAsset_asset, "f").options, __classPrivateFieldGet(this, _MutableAsset_asset, "f").value);
+    }
+    addDependency(dep) {
+        return __classPrivateFieldGet(this, _MutableAsset_asset, "f").addDependency(dep);
+    }
+    invalidateOnFileChange(filePath) {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").invalidateOnFileChange((0, projectPath_1.toProjectPath)(__classPrivateFieldGet(this, _MutableAsset_asset, "f").options.projectRoot, filePath));
+    }
+    invalidateOnFileCreate(invalidation) {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").invalidateOnFileCreate(invalidation);
+    }
+    invalidateOnEnvChange(env) {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").invalidateOnEnvChange(env);
+    }
+    invalidateOnStartup() {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").invalidateOnStartup();
+    }
+    invalidateOnBuild() {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").invalidateOnBuild();
+    }
+    isASTDirty() {
+        return __classPrivateFieldGet(this, _MutableAsset_asset, "f").isASTDirty;
+    }
+    setBuffer(buffer) {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").setBuffer(buffer);
+    }
+    setCode(code) {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").setCode(code);
+    }
+    setStream(stream) {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").setStream(stream);
+    }
+    setAST(ast) {
+        return __classPrivateFieldGet(this, _MutableAsset_asset, "f").setAST(ast);
+    }
+    addURLDependency(url, opts) {
+        return this.addDependency({
+            specifier: url,
+            specifierType: 'url',
+            priority: 'lazy',
+            ...opts,
+        });
+    }
+    setEnvironment(env) {
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").value.env = (0, Environment_2.createEnvironment)({
+            ...env,
+            loc: (0, utils_1.toInternalSourceLocation)(__classPrivateFieldGet(this, _MutableAsset_asset, "f").options.projectRoot, env.loc),
+        });
+        __classPrivateFieldGet(this, _MutableAsset_asset, "f").updateId();
+    }
+}
+exports.MutableAsset = MutableAsset;
+_MutableAsset_asset = new WeakMap();

package/dist/public/Bundle.js

@@ -0,0 +1,224 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Bundle_bundle, _Bundle_bundleGraph, _Bundle_options, _NamedBundle_bundle, _NamedBundle_bundleGraph, _NamedBundle_options, _PackagedBundle_bundle, _PackagedBundle_bundleGraph, _PackagedBundle_options, _PackagedBundle_bundleInfo;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackagedBundle = exports.NamedBundle = exports.Bundle = void 0;
+exports.bundleToInternalBundle = bundleToInternalBundle;
+exports.bundleToInternalBundleGraph = bundleToInternalBundleGraph;
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const utils_1 = require("@atlaspack/utils");
+const Asset_1 = require("./Asset");
+const graph_1 = require("@atlaspack/graph");
+const Environment_1 = __importDefault(require("./Environment"));
+const Dependency_1 = require("./Dependency");
+const Target_1 = __importDefault(require("./Target"));
+const types_1 = require("../types");
+const projectPath_1 = require("../projectPath");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const internalBundleToBundle = new utils_1.DefaultWeakMap(() => new utils_1.DefaultWeakMap(() => new WeakMap()));
+const internalBundleToNamedBundle = new utils_1.DefaultWeakMap(() => new utils_1.DefaultWeakMap(() => new WeakMap()));
+const internalBundleToPackagedBundle = new utils_1.DefaultWeakMap(() => new utils_1.DefaultWeakMap(() => new WeakMap()));
+// Friendly access for other modules within this package that need access
+// to the internal bundle.
+const _bundleToInternalBundle = new WeakMap();
+function bundleToInternalBundle(bundle) {
+    return (0, nullthrows_1.default)(_bundleToInternalBundle.get(bundle));
+}
+const _bundleToInternalBundleGraph = new WeakMap();
+function bundleToInternalBundleGraph(bundle) {
+    return (0, nullthrows_1.default)(_bundleToInternalBundleGraph.get(bundle));
+}
+// Require this private object to be present when invoking these constructors,
+// preventing others from using them. They should use the static `get` method.
+let _private = {};
+class Bundle {
+    [(_Bundle_bundle = new WeakMap(), _Bundle_bundleGraph = new WeakMap(), _Bundle_options = new WeakMap(), inspect)]() {
+        return `Bundle(${__classPrivateFieldGet(this, _Bundle_bundle, "f").id})`;
+    }
+    constructor(sentinel, bundle, bundleGraph, options) {
+        _Bundle_bundle.set(this, void 0);
+        _Bundle_bundleGraph.set(this, void 0);
+        _Bundle_options.set(this, void 0);
+        if (sentinel !== _private) {
+            throw new Error('Unexpected public usage');
+        }
+        __classPrivateFieldSet(this, _Bundle_bundle, bundle, "f");
+        __classPrivateFieldSet(this, _Bundle_bundleGraph, bundleGraph, "f");
+        __classPrivateFieldSet(this, _Bundle_options, options, "f");
+    }
+    static get(internalBundle, bundleGraph, options) {
+        let existingMap = internalBundleToBundle.get(options).get(bundleGraph);
+        let existing = existingMap.get(internalBundle);
+        if (existing != null) {
+            return existing;
+        }
+        let bundle = new Bundle(_private, internalBundle, bundleGraph, options);
+        _bundleToInternalBundle.set(bundle, internalBundle);
+        _bundleToInternalBundleGraph.set(bundle, bundleGraph);
+        existingMap.set(internalBundle, bundle);
+        return bundle;
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").id;
+    }
+    get hashReference() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").hashReference;
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").type;
+    }
+    get env() {
+        return new Environment_1.default((0, EnvironmentManager_1.fromEnvironmentId)(__classPrivateFieldGet(this, _Bundle_bundle, "f").env), __classPrivateFieldGet(this, _Bundle_options, "f"));
+    }
+    get needsStableName() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").needsStableName;
+    }
+    get bundleBehavior() {
+        let bundleBehavior = __classPrivateFieldGet(this, _Bundle_bundle, "f").bundleBehavior;
+        return bundleBehavior != null ? types_1.BundleBehaviorNames[bundleBehavior] : null;
+    }
+    get isSplittable() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").isSplittable;
+    }
+    get manualSharedBundle() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").manualSharedBundle;
+    }
+    get target() {
+        return new Target_1.default(__classPrivateFieldGet(this, _Bundle_bundle, "f").target, __classPrivateFieldGet(this, _Bundle_options, "f"));
+    }
+    hasAsset(asset) {
+        return __classPrivateFieldGet(this, _Bundle_bundleGraph, "f").bundleHasAsset(__classPrivateFieldGet(this, _Bundle_bundle, "f"), (0, Asset_1.assetToAssetValue)(asset));
+    }
+    hasDependency(dep) {
+        return __classPrivateFieldGet(this, _Bundle_bundleGraph, "f").bundleHasDependency(__classPrivateFieldGet(this, _Bundle_bundle, "f"), (0, Dependency_1.dependencyToInternalDependency)(dep));
+    }
+    getEntryAssets() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").entryAssetIds.map((id) => {
+            let assetNode = __classPrivateFieldGet(this, _Bundle_bundleGraph, "f")._graph.getNodeByContentKey(id);
+            (0, assert_1.default)(assetNode != null && assetNode.type === 'asset');
+            return (0, Asset_1.assetFromValue)(assetNode.value, __classPrivateFieldGet(this, _Bundle_options, "f"));
+        });
+    }
+    getMainEntry() {
+        if (__classPrivateFieldGet(this, _Bundle_bundle, "f").mainEntryId != null) {
+            let assetNode = __classPrivateFieldGet(this, _Bundle_bundleGraph, "f")._graph.getNodeByContentKey(__classPrivateFieldGet(this, _Bundle_bundle, "f").mainEntryId);
+            (0, assert_1.default)(assetNode != null && assetNode.type === 'asset');
+            return (0, Asset_1.assetFromValue)(assetNode.value, __classPrivateFieldGet(this, _Bundle_options, "f"));
+        }
+    }
+    traverse(visit) {
+        return __classPrivateFieldGet(this, _Bundle_bundleGraph, "f").traverseBundle(__classPrivateFieldGet(this, _Bundle_bundle, "f"), 
+        // @ts-expect-error TS2345
+        (0, graph_1.mapVisitor)((node) => {
+            if (node.type === 'asset') {
+                return {
+                    type: 'asset',
+                    value: (0, Asset_1.assetFromValue)(node.value, __classPrivateFieldGet(this, _Bundle_options, "f")),
+                };
+            }
+            else if (node.type === 'dependency') {
+                return {
+                    type: 'dependency',
+                    value: (0, Dependency_1.getPublicDependency)(node.value, __classPrivateFieldGet(this, _Bundle_options, "f")),
+                };
+            }
+        }, visit));
+    }
+    traverseAssets(visit, startAsset) {
+        return __classPrivateFieldGet(this, _Bundle_bundleGraph, "f").traverseAssets(__classPrivateFieldGet(this, _Bundle_bundle, "f"), (0, graph_1.mapVisitor)((asset) => (0, Asset_1.assetFromValue)(asset, __classPrivateFieldGet(this, _Bundle_options, "f")), visit), startAsset ? (0, Asset_1.assetToAssetValue)(startAsset) : undefined);
+    }
+}
+exports.Bundle = Bundle;
+class NamedBundle extends Bundle {
+    constructor(sentinel, bundle, bundleGraph, options) {
+        super(sentinel, bundle, bundleGraph, options);
+        _NamedBundle_bundle.set(this, void 0);
+        _NamedBundle_bundleGraph.set(this, void 0);
+        _NamedBundle_options.set(this, void 0);
+        __classPrivateFieldSet(this, _NamedBundle_bundle, bundle, "f"); // Repeating for flow
+        __classPrivateFieldSet(this, _NamedBundle_bundleGraph, bundleGraph, "f"); // Repeating for flow
+        __classPrivateFieldSet(this, _NamedBundle_options, options, "f");
+    }
+    static get(internalBundle, bundleGraph, options) {
+        let existingMap = internalBundleToNamedBundle.get(options).get(bundleGraph);
+        let existing = existingMap.get(internalBundle);
+        if (existing != null) {
+            return existing;
+        }
+        let namedBundle = new NamedBundle(_private, internalBundle, bundleGraph, options);
+        _bundleToInternalBundle.set(namedBundle, internalBundle);
+        _bundleToInternalBundleGraph.set(namedBundle, bundleGraph);
+        existingMap.set(internalBundle, namedBundle);
+        return namedBundle;
+    }
+    get name() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _NamedBundle_bundle, "f").name);
+    }
+    get displayName() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _NamedBundle_bundle, "f").displayName);
+    }
+    get publicId() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _NamedBundle_bundle, "f").publicId);
+    }
+}
+exports.NamedBundle = NamedBundle;
+_NamedBundle_bundle = new WeakMap(), _NamedBundle_bundleGraph = new WeakMap(), _NamedBundle_options = new WeakMap();
+class PackagedBundle extends NamedBundle {
+    constructor(sentinel, bundle, bundleGraph, options) {
+        super(sentinel, bundle, bundleGraph, options);
+        _PackagedBundle_bundle.set(this, void 0);
+        _PackagedBundle_bundleGraph.set(this, void 0);
+        _PackagedBundle_options.set(this, void 0);
+        _PackagedBundle_bundleInfo.set(this, void 0);
+        __classPrivateFieldSet(this, _PackagedBundle_bundle, bundle, "f"); // Repeating for flow
+        __classPrivateFieldSet(this, _PackagedBundle_bundleGraph, bundleGraph, "f"); // Repeating for flow
+        __classPrivateFieldSet(this, _PackagedBundle_options, options, "f"); // Repeating for flow
+    }
+    static get(internalBundle, bundleGraph, options) {
+        let existingMap = internalBundleToPackagedBundle
+            .get(options)
+            .get(bundleGraph);
+        let existing = existingMap.get(internalBundle);
+        if (existing != null) {
+            return existing;
+        }
+        let packagedBundle = new PackagedBundle(_private, internalBundle, bundleGraph, options);
+        _bundleToInternalBundle.set(packagedBundle, internalBundle);
+        _bundleToInternalBundleGraph.set(packagedBundle, bundleGraph);
+        existingMap.set(internalBundle, packagedBundle);
+        return packagedBundle;
+    }
+    static getWithInfo(internalBundle, bundleGraph, options, bundleInfo) {
+        let packagedBundle = PackagedBundle.get(internalBundle, bundleGraph, options);
+        __classPrivateFieldSet(packagedBundle, _PackagedBundle_bundleInfo, bundleInfo, "f");
+        return packagedBundle;
+    }
+    get filePath() {
+        return (0, projectPath_1.fromProjectPath)(__classPrivateFieldGet(this, _PackagedBundle_options, "f").projectRoot, (0, nullthrows_1.default)(__classPrivateFieldGet(this, _PackagedBundle_bundleInfo, "f")).filePath);
+    }
+    get type() {
+        // The bundle type may be overridden in the packager.
+        // However, inline bundles will not have a bundleInfo here since they are not written to the filesystem.
+        return __classPrivateFieldGet(this, _PackagedBundle_bundleInfo, "f") ? __classPrivateFieldGet(this, _PackagedBundle_bundleInfo, "f").type : __classPrivateFieldGet(this, _PackagedBundle_bundle, "f").type;
+    }
+    get stats() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _PackagedBundle_bundleInfo, "f")).stats;
+    }
+}
+exports.PackagedBundle = PackagedBundle;
+_PackagedBundle_bundle = new WeakMap(), _PackagedBundle_bundleGraph = new WeakMap(), _PackagedBundle_options = new WeakMap(), _PackagedBundle_bundleInfo = new WeakMap();