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

package/dist/public/BundleGraph.js

@@ -0,0 +1,359 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 _BundleGraph_graph, _BundleGraph_options, _BundleGraph_createBundle;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleGraphToInternalBundleGraph = bundleGraphToInternalBundleGraph;
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const graph_1 = require("@atlaspack/graph");
+const Asset_1 = require("./Asset");
+const Bundle_1 = require("./Bundle");
+const Dependency_1 = __importStar(require("./Dependency"));
+const Target_1 = require("./Target");
+const utils_1 = require("../utils");
+const BundleGroup_1 = __importStar(require("./BundleGroup"));
+// 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_1.default)(_bundleGraphToInternalBundleGraph.get(bundleGraph));
+}
+class BundleGraph {
+    constructor(graph, createBundle, options) {
+        _BundleGraph_graph.set(this, void 0);
+        _BundleGraph_options.set(this, void 0);
+        _BundleGraph_createBundle.set(this, void 0);
+        __classPrivateFieldSet(this, _BundleGraph_graph, graph, "f");
+        __classPrivateFieldSet(this, _BundleGraph_options, options, "f");
+        __classPrivateFieldSet(this, _BundleGraph_createBundle, createBundle, "f");
+        _bundleGraphToInternalBundleGraph.set(this, graph);
+    }
+    getAssetById(id) {
+        return (0, Asset_1.assetFromValue)(__classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetById(id), __classPrivateFieldGet(this, _BundleGraph_options, "f"));
+    }
+    getAssetPublicId(asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetPublicId((0, Asset_1.assetToAssetValue)(asset));
+    }
+    isDependencySkipped(dep) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isDependencySkipped((0, Dependency_1.dependencyToInternalDependency)(dep));
+    }
+    getResolvedAsset(dep, bundle) {
+        let resolution = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getResolvedAsset((0, Dependency_1.dependencyToInternalDependency)(dep), bundle && (0, Bundle_1.bundleToInternalBundle)(bundle));
+        if (resolution) {
+            return (0, Asset_1.assetFromValue)(resolution, __classPrivateFieldGet(this, _BundleGraph_options, "f"));
+        }
+    }
+    getIncomingDependencies(asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getIncomingDependencies((0, Asset_1.assetToAssetValue)(asset))
+            .map((dep) => (0, Dependency_1.getPublicDependency)(dep, __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getAssetWithDependency(dep) {
+        let asset = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetWithDependency((0, Dependency_1.dependencyToInternalDependency)(dep));
+        if (asset) {
+            return (0, Asset_1.assetFromValue)(asset, __classPrivateFieldGet(this, _BundleGraph_options, "f"));
+        }
+    }
+    getBundleGroupsContainingBundle(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundleGroupsContainingBundle((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundleGroup) => new BundleGroup_1.default(bundleGroup, __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getReferencedBundles(bundle, opts) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getReferencedBundles((0, Bundle_1.bundleToInternalBundle)(bundle), opts)
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getReferencingBundles(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getReferencingBundles((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    resolveAsyncDependency(dependency, bundle) {
+        let resolved = __classPrivateFieldGet(this, _BundleGraph_graph, "f").resolveAsyncDependency((0, Dependency_1.dependencyToInternalDependency)(dependency), bundle && (0, Bundle_1.bundleToInternalBundle)(bundle));
+        if (resolved == null) {
+            return;
+        }
+        else if (resolved.type === 'bundle_group') {
+            return {
+                type: 'bundle_group',
+                value: new BundleGroup_1.default(resolved.value, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+            };
+        }
+        return {
+            type: 'asset',
+            value: (0, Asset_1.assetFromValue)(resolved.value, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+        };
+    }
+    getReferencedBundle(dependency, bundle) {
+        let result = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getReferencedBundle((0, Dependency_1.dependencyToInternalDependency)(dependency), (0, Bundle_1.bundleToInternalBundle)(bundle));
+        if (result != null) {
+            return __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, result, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f"));
+        }
+    }
+    getDependencies(asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getDependencies((0, Asset_1.assetToAssetValue)(asset))
+            .map((dep) => (0, Dependency_1.getPublicDependency)(dep, __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    isAssetReachableFromBundle(asset, bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isAssetReachableFromBundle((0, Asset_1.assetToAssetValue)(asset), (0, Bundle_1.bundleToInternalBundle)(bundle));
+    }
+    isAssetReferenced(bundle, asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isAssetReferenced((0, Bundle_1.bundleToInternalBundle)(bundle), (0, Asset_1.assetToAssetValue)(asset));
+    }
+    hasParentBundleOfType(bundle, type) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").hasParentBundleOfType((0, Bundle_1.bundleToInternalBundle)(bundle), type);
+    }
+    getBundlesInBundleGroup(bundleGroup, opts) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundlesInBundleGroup((0, BundleGroup_1.bundleGroupToInternalBundleGroup)(bundleGroup), opts)
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getBundles(opts) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundles(opts)
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    isEntryBundleGroup(bundleGroup) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isEntryBundleGroup((0, BundleGroup_1.bundleGroupToInternalBundleGroup)(bundleGroup));
+    }
+    getChildBundles(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getChildBundles((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getParentBundles(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getParentBundles((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getSymbolResolution(asset, symbol, boundary) {
+        let res = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getSymbolResolution((0, Asset_1.assetToAssetValue)(asset), symbol, boundary ? (0, Bundle_1.bundleToInternalBundle)(boundary) : null);
+        return {
+            asset: (0, Asset_1.assetFromValue)(res.asset, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+            exportSymbol: res.exportSymbol,
+            symbol: res.symbol,
+            loc: (0, utils_1.fromInternalSourceLocation)(__classPrivateFieldGet(this, _BundleGraph_options, "f").projectRoot, res.loc),
+        };
+    }
+    getExportedSymbols(asset, boundary) {
+        let res = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getExportedSymbols((0, Asset_1.assetToAssetValue)(asset), boundary ? (0, Bundle_1.bundleToInternalBundle)(boundary) : null);
+        return res.map((e) => ({
+            asset: (0, Asset_1.assetFromValue)(e.asset, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+            exportSymbol: e.exportSymbol,
+            symbol: e.symbol,
+            loc: (0, utils_1.fromInternalSourceLocation)(__classPrivateFieldGet(this, _BundleGraph_options, "f").projectRoot, e.loc),
+            exportAs: e.exportAs,
+        }));
+    }
+    traverse(visit, start, opts) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").traverse(
+        // @ts-expect-error TS2345
+        (0, graph_1.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?.skipUnusedDependencies &&
+                node.type === 'dependency' &&
+                (node.hasDeferred || node.excluded)) {
+                actions.skipChildren();
+                return null;
+            }
+            return node.type === 'asset'
+                ? { type: 'asset', value: (0, Asset_1.assetFromValue)(node.value, __classPrivateFieldGet(this, _BundleGraph_options, "f")) }
+                : {
+                    type: 'dependency',
+                    value: (0, Dependency_1.getPublicDependency)(node.value, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+                };
+        }, visit), start ? (0, Asset_1.assetToAssetValue)(start) : undefined);
+    }
+    traverseBundles(visit, startBundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").traverseBundles((0, graph_1.mapVisitor)((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")), visit), startBundle == null ? undefined : (0, Bundle_1.bundleToInternalBundle)(startBundle));
+    }
+    getBundlesWithAsset(asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundlesWithAsset((0, Asset_1.assetToAssetValue)(asset))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getBundlesWithDependency(dependency) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundlesWithDependency((0, Dependency_1.dependencyToInternalDependency)(dependency))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getUsedSymbols(v) {
+        if (v instanceof Asset_1.Asset) {
+            return __classPrivateFieldGet(this, _BundleGraph_graph, "f").getUsedSymbolsAsset((0, Asset_1.assetToAssetValue)(v));
+        }
+        else {
+            (0, assert_1.default)(v instanceof Dependency_1.default);
+            return __classPrivateFieldGet(this, _BundleGraph_graph, "f").getUsedSymbolsDependency((0, Dependency_1.dependencyToInternalDependency)(v));
+        }
+    }
+    getEntryRoot(target) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").getEntryRoot(__classPrivateFieldGet(this, _BundleGraph_options, "f").projectRoot, (0, Target_1.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 __classPrivateFieldGet(this, _BundleGraph_graph, "f")._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 = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getResolvedAsset(dep, (0, Bundle_1.bundleToInternalBundle)(bundle));
+                    if (asset &&
+                        __classPrivateFieldGet(this, _BundleGraph_graph, "f").bundleHasAsset((0, Bundle_1.bundleToInternalBundle)(bundle), asset)) {
+                        // Asset is in the same bundle, we know it doesn't need to be loaded externally
+                        return [asset, []];
+                    }
+                    const resolvedAsync = __classPrivateFieldGet(this, _BundleGraph_graph, "f").resolveAsyncDependency(dep, (0, Bundle_1.bundleToInternalBundle)(bundle));
+                    if (resolvedAsync?.type === 'asset') {
+                        // Single bundle to load dynamically
+                        return [
+                            resolvedAsync.value,
+                            [
+                                __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, (0, nullthrows_1.default)(__classPrivateFieldGet(this, _BundleGraph_graph, "f").getReferencedBundle(dep, (0, Bundle_1.bundleToInternalBundle)(bundle)), `Failed to load referenced bundle for '${dep.specifier}' specifier from '${String(dep.sourcePath)}'`), __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+                            ],
+                        ];
+                    }
+                    else if (resolvedAsync) {
+                        // Bundle group means we have multiple bundles to load first
+                        return [
+                            __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetById(resolvedAsync.value.entryAssetId),
+                            __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+                                .getBundlesInBundleGroup(resolvedAsync.value)
+                                .map((b) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, b, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f"))),
+                        ];
+                    }
+                    else {
+                        return [
+                            (0, nullthrows_1.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_1.default)(deps.find((dep) => dep.id === condition.ifTrueDependency.id), 'ifTrueDependency was null'),
+                    ifFalseDependency: (0, nullthrows_1.default)(deps.find((dep) => dep.id === condition.ifFalseDependency.id), 'ifFalseDependency was null'),
+                    ifTrueBundles,
+                    ifFalseBundles,
+                    ifTrueAssetId: __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetPublicId(trueAsset),
+                    ifFalseAssetId: __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetPublicId(falseAsset),
+                });
+            }
+        }
+        // @ts-expect-error TS2322
+        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 __classPrivateFieldGet(this, _BundleGraph_graph, "f")._conditions.values()) {
+            let assets = Array.from(cond.assets).map((asset) => (0, nullthrows_1.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_1.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_1.default)(resolved.type === 'bundle_group');
+                    return this.getBundlesInBundleGroup(resolved.value);
+                };
+                // @ts-expect-error TS2345
+                ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+                // @ts-expect-error TS2345
+                ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+            }
+            for (let bundle of bundles) {
+                const conditions = bundleConditions.get(bundle.id) ?? new Map();
+                const currentCondition = conditions.get(cond.key);
+                conditions.set(cond.key, {
+                    bundle,
+                    ifTrueBundles: [
+                        ...(currentCondition?.ifTrueBundles ?? []),
+                        ...ifTrueBundles,
+                    ],
+                    ifFalseBundles: [
+                        ...(currentCondition?.ifFalseBundles ?? []),
+                        ...ifFalseBundles,
+                    ],
+                });
+                bundleConditions.set(bundle.id, conditions);
+            }
+        }
+        return bundleConditions;
+    }
+    getReferencedConditionalBundles(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getReferencedConditionalBundles((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((result) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, result, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+}
+_BundleGraph_graph = new WeakMap(), _BundleGraph_options = new WeakMap(), _BundleGraph_createBundle = new WeakMap();
+exports.default = BundleGraph;

package/dist/public/BundleGroup.js

@@ -0,0 +1,53 @@
+"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 _BundleGroup_bundleGroup, _BundleGroup_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleGroupToInternalBundleGroup = bundleGroupToInternalBundleGroup;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const Target_1 = __importDefault(require("./Target"));
+const internalBundleGroupToBundleGroup = new WeakMap();
+const _bundleGroupToInternalBundleGroup = new WeakMap();
+function bundleGroupToInternalBundleGroup(target) {
+    return (0, nullthrows_1.default)(_bundleGroupToInternalBundleGroup.get(target));
+}
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+class BundleGroup {
+    constructor(bundleGroup, options) {
+        // @ts-expect-error TS2564
+        _BundleGroup_bundleGroup.set(this, void 0);
+        // @ts-expect-error TS2564
+        _BundleGroup_options.set(this, void 0);
+        let existing = internalBundleGroupToBundleGroup.get(bundleGroup);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _BundleGroup_bundleGroup, bundleGroup, "f");
+        __classPrivateFieldSet(this, _BundleGroup_options, options, "f");
+        _bundleGroupToInternalBundleGroup.set(this, bundleGroup);
+        internalBundleGroupToBundleGroup.set(bundleGroup, this);
+        return this;
+    }
+    get target() {
+        return new Target_1.default(__classPrivateFieldGet(this, _BundleGroup_bundleGroup, "f").target, __classPrivateFieldGet(this, _BundleGroup_options, "f"));
+    }
+    get entryAssetId() {
+        return __classPrivateFieldGet(this, _BundleGroup_bundleGroup, "f").entryAssetId;
+    }
+    [(_BundleGroup_bundleGroup = new WeakMap(), _BundleGroup_options = new WeakMap(), inspect)]() {
+        return `BundleGroup(${this.entryAssetId})`;
+    }
+}
+exports.default = BundleGroup;