@atlaspack/core 2.24.1 → 2.24.2

package/dist/public/Environment.js

@@ -0,0 +1,278 @@
+"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 _Environment_environment, _Environment_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISOLATED_ENVS = exports.BROWSER_ENVS = void 0;
+exports.environmentToInternalEnvironment = environmentToInternalEnvironment;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const browserslist_1 = __importDefault(require("browserslist"));
+const semver_1 = __importDefault(require("semver"));
+const utils_1 = require("../utils");
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+exports.BROWSER_ENVS = new Set([
+    'browser',
+    'web-worker',
+    'service-worker',
+    'worklet',
+    'tesseract',
+    'electron-renderer',
+]);
+const ELECTRON_ENVS = new Set(['electron-main', 'electron-renderer']);
+const NODE_ENVS = new Set(['node', ...ELECTRON_ENVS]);
+const WORKER_ENVS = new Set(['web-worker', 'service-worker']);
+exports.ISOLATED_ENVS = new Set([
+    ...WORKER_ENVS,
+    'worklet',
+    'tesseract',
+]);
+const ALL_BROWSERS = [
+    'chrome',
+    'and_chr',
+    'edge',
+    'firefox',
+    'and_ff',
+    'safari',
+    'ios',
+    'samsung',
+    'opera',
+    'ie',
+    'op_mini',
+    'blackberry',
+    'op_mob',
+    'ie_mob',
+    'and_uc',
+    'and_qq',
+    'baidu',
+    'kaios',
+];
+// See require("caniuse-api").getSupport(<feature name>)
+const supportData = {
+    esmodules: {
+        edge: '16',
+        firefox: '60',
+        chrome: '61',
+        safari: '10.1',
+        opera: '48',
+        ios: '10.3',
+        android: '76',
+        and_chr: '76',
+        and_ff: '68',
+        samsung: '8.2',
+        and_qq: '10.4',
+        op_mob: '64',
+    },
+    'dynamic-import': {
+        edge: '76',
+        firefox: '67',
+        chrome: '63',
+        safari: '11.1',
+        opera: '50',
+        ios: '11.3',
+        android: '63',
+        and_chr: '63',
+        and_ff: '67',
+        samsung: '8',
+        and_qq: '10.4',
+        op_mob: '64',
+    },
+    'worker-module': {
+        edge: '80',
+        chrome: '80',
+        opera: '67',
+        android: '81',
+        and_chr: '86',
+    },
+    'service-worker-module': {
+    // TODO: Safari 14.1??
+    },
+    'import-meta-url': {
+        edge: '79',
+        firefox: '62',
+        chrome: '64',
+        safari: '11.1',
+        opera: '51',
+        ios: '12',
+        android: '64',
+        and_chr: '64',
+        and_ff: '62',
+        samsung: '9.2',
+        and_qq: '10.4',
+        op_mob: '64',
+    },
+    'arrow-functions': {
+        chrome: '47',
+        opera: '34',
+        edge: '13',
+        firefox: '45',
+        safari: '10',
+        node: '6',
+        ios: '10',
+        samsung: '5',
+        electron: '0.36',
+        android: '50',
+        qq: '10.4',
+        baidu: '7.12',
+        kaios: '2.5',
+        and_chr: '50',
+        and_qq: '12.12',
+        op_mob: '64',
+    },
+    'global-this': {
+        chrome: '75',
+        edge: '79',
+        safari: '12.1',
+        firefox: '65',
+        opera: '58',
+        node: '12',
+        and_chr: '71',
+        ios: '12.2',
+        android: '71',
+        samsung: '10.1',
+    },
+};
+const internalEnvironmentToEnvironment = new WeakMap();
+const _environmentToInternalEnvironment = new WeakMap();
+function environmentToInternalEnvironment(environment) {
+    return (0, nullthrows_1.default)(_environmentToInternalEnvironment.get(environment));
+}
+class Environment {
+    constructor(env, options) {
+        // @ts-expect-error TS2564
+        _Environment_environment.set(this, void 0);
+        // @ts-expect-error TS2564
+        _Environment_options.set(this, void 0);
+        let existing = internalEnvironmentToEnvironment.get(env);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _Environment_environment, env, "f");
+        __classPrivateFieldSet(this, _Environment_options, options, "f");
+        _environmentToInternalEnvironment.set(this, env);
+        internalEnvironmentToEnvironment.set(env, this);
+        return this;
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").id;
+    }
+    get context() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").context;
+    }
+    get engines() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").engines;
+    }
+    get includeNodeModules() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").includeNodeModules;
+    }
+    get outputFormat() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").outputFormat;
+    }
+    get sourceType() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").sourceType;
+    }
+    get isLibrary() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").isLibrary;
+    }
+    get shouldOptimize() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").shouldOptimize;
+    }
+    get shouldScopeHoist() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").shouldScopeHoist;
+    }
+    get sourceMap() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").sourceMap;
+    }
+    get loc() {
+        return (0, utils_1.fromInternalSourceLocation)(__classPrivateFieldGet(this, _Environment_options, "f").projectRoot, __classPrivateFieldGet(this, _Environment_environment, "f").loc);
+    }
+    get unstableSingleFileOutput() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").unstableSingleFileOutput;
+    }
+    get customEnv() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").customEnv;
+    }
+    [(_Environment_environment = new WeakMap(), _Environment_options = new WeakMap(), inspect)]() {
+        return `Env(${__classPrivateFieldGet(this, _Environment_environment, "f").context})`;
+    }
+    isBrowser() {
+        return exports.BROWSER_ENVS.has(__classPrivateFieldGet(this, _Environment_environment, "f").context);
+    }
+    isNode() {
+        return NODE_ENVS.has(__classPrivateFieldGet(this, _Environment_environment, "f").context);
+    }
+    isElectron() {
+        return ELECTRON_ENVS.has(__classPrivateFieldGet(this, _Environment_environment, "f").context);
+    }
+    isIsolated() {
+        return exports.ISOLATED_ENVS.has(__classPrivateFieldGet(this, _Environment_environment, "f").context);
+    }
+    isWorker() {
+        return WORKER_ENVS.has(__classPrivateFieldGet(this, _Environment_environment, "f").context);
+    }
+    isWorklet() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").context === 'worklet';
+    }
+    isTesseract() {
+        return __classPrivateFieldGet(this, _Environment_environment, "f").context === 'tesseract';
+    }
+    matchesEngines(minVersions, defaultValue = false) {
+        // Determine if the environment matches some minimum version requirements.
+        // For browsers, we run a browserslist query with and without the minimum
+        // required browsers and compare the lists. For node, we just check semver.
+        if (this.isBrowser() && this.engines.browsers != null) {
+            let targetBrowsers = this.engines.browsers;
+            let browsers = targetBrowsers != null && !Array.isArray(targetBrowsers)
+                ? [targetBrowsers]
+                : targetBrowsers;
+            // If outputting esmodules, exclude browsers without support.
+            if (this.outputFormat === 'esmodule') {
+                browsers = [...browsers, ...getExcludedBrowsers(supportData.esmodules)];
+            }
+            let matchedBrowsers = (0, browserslist_1.default)(browsers);
+            if (matchedBrowsers.length === 0) {
+                return false;
+            }
+            let minBrowsers = getExcludedBrowsers(minVersions);
+            let withoutMinBrowsers = (0, browserslist_1.default)([...browsers, ...minBrowsers]);
+            return matchedBrowsers.length === withoutMinBrowsers.length;
+        }
+        else if (this.isNode() && this.engines.node != null) {
+            return (minVersions.node != null &&
+                !semver_1.default.intersects(`< ${minVersions.node}`, this.engines.node));
+        }
+        return defaultValue;
+    }
+    supports(feature, defaultValue) {
+        let engines = supportData[feature];
+        if (!engines) {
+            throw new Error('Unknown environment feature: ' + feature);
+        }
+        return this.matchesEngines(engines, defaultValue);
+    }
+}
+exports.default = Environment;
+function getExcludedBrowsers(minVersions) {
+    let browsers = [];
+    for (let browser of ALL_BROWSERS) {
+        let version = minVersions[browser];
+        if (version) {
+            browsers.push(`not ${browser} < ${version}`);
+        }
+        else {
+            browsers.push(`not ${browser} > 0`);
+        }
+    }
+    return browsers;
+}

package/dist/public/MutableBundleGraph.js

@@ -0,0 +1,277 @@
+"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 _MutableBundleGraph_graph, _MutableBundleGraph_options, _MutableBundleGraph_bundlePublicIds;
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const rust_1 = require("@atlaspack/rust");
+const BundleGraph_1 = __importDefault(require("./BundleGraph"));
+const BundleGraph_2 = require("../BundleGraph");
+const Bundle_1 = require("./Bundle");
+const Asset_1 = require("./Asset");
+const utils_1 = require("../utils");
+const Dependency_1 = __importStar(require("./Dependency"));
+const Environment_1 = require("./Environment");
+const Target_1 = require("./Target");
+const constants_1 = require("../constants");
+const projectPath_1 = require("../projectPath");
+const types_1 = require("../types");
+const BundleGroup_1 = __importStar(require("./BundleGroup"));
+const IdentifierRegistry_1 = require("../IdentifierRegistry");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+function createBundleId(data) {
+    const { entryAssetId, uniqueKey, distDir, bundleBehavior } = data;
+    const id = (0, rust_1.hashString)(`bundle:${String(entryAssetId != null ? entryAssetId : uniqueKey)}${(0, projectPath_1.fromProjectPathRelative)(distDir)}${bundleBehavior ?? ''}`);
+    IdentifierRegistry_1.identifierRegistry.addIdentifier('bundle', id, data);
+    return id;
+}
+class MutableBundleGraph extends BundleGraph_1.default {
+    constructor(graph, options) {
+        super(graph, Bundle_1.Bundle.get.bind(Bundle_1.Bundle), options);
+        _MutableBundleGraph_graph.set(this, void 0);
+        _MutableBundleGraph_options.set(this, void 0);
+        _MutableBundleGraph_bundlePublicIds.set(this, new Set());
+        __classPrivateFieldSet(this, _MutableBundleGraph_graph, graph, "f");
+        __classPrivateFieldSet(this, _MutableBundleGraph_options, options, "f");
+    }
+    addAssetToBundle(asset, bundle) {
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").addAssetToBundle((0, Asset_1.assetToAssetValue)(asset), (0, Bundle_1.bundleToInternalBundle)(bundle));
+    }
+    addAssetGraphToBundle(asset, bundle, shouldSkipDependency) {
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").addAssetGraphToBundle((0, Asset_1.assetToAssetValue)(asset), (0, Bundle_1.bundleToInternalBundle)(bundle), 
+        // @ts-expect-error TS2345
+        shouldSkipDependency
+            ? (d) => 
+            // @ts-expect-error TS2345
+            shouldSkipDependency(new Dependency_1.default(d, __classPrivateFieldGet(this, _MutableBundleGraph_options, "f")))
+            : undefined);
+    }
+    addEntryToBundle(asset, bundle, shouldSkipDependency) {
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").addEntryToBundle((0, Asset_1.assetToAssetValue)(asset), (0, Bundle_1.bundleToInternalBundle)(bundle), 
+        // @ts-expect-error TS2345
+        shouldSkipDependency
+            ? (d) => 
+            // @ts-expect-error TS2345
+            shouldSkipDependency(new Dependency_1.default(d, __classPrivateFieldGet(this, _MutableBundleGraph_options, "f")))
+            : undefined);
+    }
+    createBundleGroup(dependency, target) {
+        let dependencyNode = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeByContentKey(dependency.id);
+        if (!dependencyNode) {
+            throw new Error('Dependency not found');
+        }
+        (0, assert_1.default)(dependencyNode.type === 'dependency');
+        let resolved = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").getResolvedAsset((0, Dependency_1.dependencyToInternalDependency)(dependency));
+        if (!resolved) {
+            throw new Error('Dependency did not resolve to an asset ' + dependency.id);
+        }
+        let bundleGroup = {
+            target: (0, Target_1.targetToInternalTarget)(target),
+            entryAssetId: resolved.id,
+        };
+        let bundleGroupKey = (0, utils_1.getBundleGroupId)(bundleGroup);
+        let bundleGroupNodeId = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.hasContentKey(bundleGroupKey)
+            ? __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeIdByContentKey(bundleGroupKey)
+            : __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.addNodeByContentKey(bundleGroupKey, {
+                id: bundleGroupKey,
+                type: 'bundle_group',
+                value: bundleGroup,
+            });
+        let dependencyNodeId = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeIdByContentKey(dependencyNode.id);
+        let resolvedNodeId = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeIdByContentKey(resolved.id);
+        let assetNodes = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeIdsConnectedFrom(dependencyNodeId);
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.addEdge(dependencyNodeId, bundleGroupNodeId);
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.replaceNodeIdsConnectedTo(bundleGroupNodeId, assetNodes);
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.addEdge(dependencyNodeId, resolvedNodeId, BundleGraph_2.bundleGraphEdgeTypes.references);
+        if (
+        // This check is needed for multiple targets, when we go over the same nodes twice
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.hasEdge(dependencyNodeId, resolvedNodeId, BundleGraph_2.bundleGraphEdgeTypes.null)) {
+            //nullEdgeType
+            __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.removeEdge(dependencyNodeId, resolvedNodeId);
+        }
+        if (dependency.isEntry) {
+            __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.addEdge((0, nullthrows_1.default)(__classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.rootNodeId), bundleGroupNodeId, BundleGraph_2.bundleGraphEdgeTypes.bundle);
+        }
+        else {
+            let inboundBundleNodeIds = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeIdsConnectedTo(dependencyNodeId, BundleGraph_2.bundleGraphEdgeTypes.contains);
+            for (let inboundBundleNodeId of inboundBundleNodeIds) {
+                (0, assert_1.default)(__classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNode(inboundBundleNodeId)?.type === 'bundle');
+                __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.addEdge(inboundBundleNodeId, bundleGroupNodeId, BundleGraph_2.bundleGraphEdgeTypes.bundle);
+            }
+        }
+        return new BundleGroup_1.default(bundleGroup, __classPrivateFieldGet(this, _MutableBundleGraph_options, "f"));
+    }
+    removeBundleGroup(bundleGroup) {
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").removeBundleGroup((0, BundleGroup_1.bundleGroupToInternalBundleGroup)(bundleGroup));
+    }
+    internalizeAsyncDependency(bundle, dependency) {
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").internalizeAsyncDependency((0, Bundle_1.bundleToInternalBundle)(bundle), (0, Dependency_1.dependencyToInternalDependency)(dependency));
+    }
+    createBundle(opts) {
+        // @ts-expect-error TS2339
+        let entryAsset = opts.entryAsset
+            ? // @ts-expect-error TS2339
+                (0, Asset_1.assetToAssetValue)(opts.entryAsset)
+            : null;
+        let target = (0, Target_1.targetToInternalTarget)(opts.target);
+        let bundleId = createBundleId({
+            entryAssetId: entryAsset?.id ?? null,
+            // @ts-expect-error TS2339
+            uniqueKey: opts.uniqueKey ?? null,
+            distDir: target.distDir,
+            bundleBehavior: opts.bundleBehavior ?? null,
+        });
+        let existing = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeByContentKey(bundleId);
+        if (existing != null) {
+            (0, assert_1.default)(existing.type === 'bundle');
+            return Bundle_1.Bundle.get(existing.value, __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f"), __classPrivateFieldGet(this, _MutableBundleGraph_options, "f"));
+        }
+        let publicId = (0, utils_1.getPublicId)(bundleId, (existing) => __classPrivateFieldGet(this, _MutableBundleGraph_bundlePublicIds, "f").has(existing));
+        __classPrivateFieldGet(this, _MutableBundleGraph_bundlePublicIds, "f").add(publicId);
+        let isPlaceholder = false;
+        if (entryAsset) {
+            let entryAssetNode = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeByContentKey(entryAsset.id);
+            (0, assert_1.default)(entryAssetNode?.type === 'asset', 'Entry asset does not exist');
+            isPlaceholder = entryAssetNode.requested === false;
+        }
+        let entryAssetIds = [];
+        if (entryAsset) {
+            entryAssetIds = [entryAsset.id];
+            if ((0, feature_flags_1.getFeatureFlag)('supportWebpackChunkName')) {
+                // @ts-expect-error TS2339
+                let bundleRoots = opts.bundleRoots ?? [entryAsset];
+                let bundleRootIds = bundleRoots
+                    .map(({ id }) => id)
+                    .filter((assetId) => assetId !== entryAsset.id);
+                entryAssetIds.push(...bundleRootIds);
+            }
+        }
+        let bundleNode = {
+            type: 'bundle',
+            id: bundleId,
+            value: {
+                id: bundleId,
+                hashReference: __classPrivateFieldGet(this, _MutableBundleGraph_options, "f").shouldContentHash
+                    ? constants_1.HASH_REF_PREFIX + bundleId
+                    : bundleId.slice(-8),
+                // @ts-expect-error TS2339
+                type: opts.entryAsset ? opts.entryAsset.type : opts.type,
+                // @ts-expect-error TS2339
+                env: opts.env
+                    ? // @ts-expect-error TS2339
+                        (0, EnvironmentManager_1.toEnvironmentRef)((0, Environment_1.environmentToInternalEnvironment)(opts.env))
+                    : (0, nullthrows_1.default)(entryAsset).env,
+                entryAssetIds,
+                mainEntryId: entryAsset?.id,
+                // @ts-expect-error TS2339
+                pipeline: opts.entryAsset ? opts.entryAsset.pipeline : opts.pipeline,
+                needsStableName: opts.needsStableName,
+                bundleBehavior: opts.bundleBehavior != null
+                    ? types_1.BundleBehavior[opts.bundleBehavior]
+                    : null,
+                // @ts-expect-error TS2339
+                isSplittable: opts.entryAsset
+                    ? // @ts-expect-error TS2339
+                        opts.entryAsset.isBundleSplittable
+                    : // @ts-expect-error TS2339
+                        opts.isSplittable,
+                isPlaceholder,
+                target,
+                name: null,
+                displayName: null,
+                publicId,
+                manualSharedBundle: opts.manualSharedBundle,
+            },
+        };
+        let bundleNodeId = __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.addNodeByContentKey(bundleId, bundleNode);
+        for (let assetId of entryAssetIds) {
+            __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.addEdge(bundleNodeId, __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")._graph.getNodeIdByContentKey(assetId));
+        }
+        return Bundle_1.Bundle.get(bundleNode.value, __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f"), __classPrivateFieldGet(this, _MutableBundleGraph_options, "f"));
+    }
+    addBundleToBundleGroup(bundle, bundleGroup) {
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").addBundleToBundleGroup((0, Bundle_1.bundleToInternalBundle)(bundle), (0, BundleGroup_1.bundleGroupToInternalBundleGroup)(bundleGroup));
+    }
+    createAssetReference(dependency, asset, bundle) {
+        return __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").createAssetReference((0, Dependency_1.dependencyToInternalDependency)(dependency), (0, Asset_1.assetToAssetValue)(asset), (0, Bundle_1.bundleToInternalBundle)(bundle));
+    }
+    createBundleReference(from, to) {
+        return __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").createBundleReference((0, Bundle_1.bundleToInternalBundle)(from), (0, Bundle_1.bundleToInternalBundle)(to));
+    }
+    createBundleConditionalReference(from, to) {
+        return __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").createBundleConditionalReference((0, Bundle_1.bundleToInternalBundle)(from), (0, Bundle_1.bundleToInternalBundle)(to));
+    }
+    getDependencyAssets(dependency) {
+        return __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")
+            .getDependencyAssets((0, Dependency_1.dependencyToInternalDependency)(dependency))
+            .map((asset) => (0, Asset_1.assetFromValue)(asset, __classPrivateFieldGet(this, _MutableBundleGraph_options, "f")));
+    }
+    getBundleGroupsContainingBundle(bundle) {
+        return __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")
+            .getBundleGroupsContainingBundle((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundleGroup) => new BundleGroup_1.default(bundleGroup, __classPrivateFieldGet(this, _MutableBundleGraph_options, "f")));
+    }
+    getParentBundlesOfBundleGroup(bundleGroup) {
+        return __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f")
+            .getParentBundlesOfBundleGroup((0, BundleGroup_1.bundleGroupToInternalBundleGroup)(bundleGroup))
+            .map((bundle) => Bundle_1.Bundle.get(bundle, __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f"), __classPrivateFieldGet(this, _MutableBundleGraph_options, "f")));
+    }
+    getTotalSize(asset) {
+        return __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").getTotalSize((0, Asset_1.assetToAssetValue)(asset));
+    }
+    isAssetReachableFromBundle(asset, bundle) {
+        return __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").isAssetReachableFromBundle((0, Asset_1.assetToAssetValue)(asset), (0, Bundle_1.bundleToInternalBundle)(bundle));
+    }
+    removeAssetGraphFromBundle(asset, bundle) {
+        __classPrivateFieldGet(this, _MutableBundleGraph_graph, "f").removeAssetGraphFromBundle((0, Asset_1.assetToAssetValue)(asset), (0, Bundle_1.bundleToInternalBundle)(bundle));
+    }
+}
+_MutableBundleGraph_graph = new WeakMap(), _MutableBundleGraph_options = new WeakMap(), _MutableBundleGraph_bundlePublicIds = new WeakMap();
+exports.default = MutableBundleGraph;

package/dist/public/PluginOptions.js

@@ -0,0 +1,80 @@
+"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 _PluginOptions_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+let parcelOptionsToPluginOptions = new WeakMap();
+class PluginOptions {
+    constructor(options) {
+        // @ts-expect-error TS2564
+        _PluginOptions_options.set(this, void 0);
+        let existing = parcelOptionsToPluginOptions.get(options);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _PluginOptions_options, options, "f");
+        parcelOptionsToPluginOptions.set(options, this);
+        return this;
+    }
+    get instanceId() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").instanceId;
+    }
+    get mode() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").mode;
+    }
+    get env() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").env;
+    }
+    get parcelVersion() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").parcelVersion;
+    }
+    get hmrOptions() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").hmrOptions;
+    }
+    get serveOptions() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").serveOptions;
+    }
+    get shouldBuildLazily() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").shouldBuildLazily;
+    }
+    get shouldAutoInstall() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").shouldAutoInstall;
+    }
+    get logLevel() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").logLevel;
+    }
+    get cacheDir() {
+        // TODO: remove this. Probably bad if there are other types of caches.
+        // Maybe expose the Cache object instead?
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").cacheDir;
+    }
+    get projectRoot() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").projectRoot;
+    }
+    get inputFS() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").inputFS;
+    }
+    get outputFS() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").outputFS;
+    }
+    get packageManager() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").packageManager;
+    }
+    get detailedReport() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").detailedReport;
+    }
+    get featureFlags() {
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").featureFlags;
+    }
+}
+_PluginOptions_options = new WeakMap();
+exports.default = PluginOptions;