@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

package/dist/index.js

@@ -0,0 +1,62 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentManager = exports.Environment = exports.createEnvironment = exports.resolveOptions = exports.ATLASPACK_VERSION = exports.WORKER_PATH = exports.INTERNAL_TRANSFORM = exports.INTERNAL_RESOLVE = exports.createWorkerFarm = exports.BuildError = exports.Parcel = exports.Atlaspack = exports.default = void 0;
+const EnvironmentManager = __importStar(require("./EnvironmentManager"));
+exports.EnvironmentManager = EnvironmentManager;
+var Atlaspack_1 = require("./Atlaspack");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Atlaspack_1).default; } });
+Object.defineProperty(exports, "Atlaspack", { enumerable: true, get: function () { return __importDefault(Atlaspack_1).default; } });
+Object.defineProperty(exports, "Parcel", { enumerable: true, get: function () { return __importDefault(Atlaspack_1).default; } });
+Object.defineProperty(exports, "BuildError", { enumerable: true, get: function () { return Atlaspack_1.BuildError; } });
+Object.defineProperty(exports, "createWorkerFarm", { enumerable: true, get: function () { return Atlaspack_1.createWorkerFarm; } });
+Object.defineProperty(exports, "INTERNAL_RESOLVE", { enumerable: true, get: function () { return Atlaspack_1.INTERNAL_RESOLVE; } });
+Object.defineProperty(exports, "INTERNAL_TRANSFORM", { enumerable: true, get: function () { return Atlaspack_1.INTERNAL_TRANSFORM; } });
+Object.defineProperty(exports, "WORKER_PATH", { enumerable: true, get: function () { return Atlaspack_1.WORKER_PATH; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "ATLASPACK_VERSION", { enumerable: true, get: function () { return constants_1.ATLASPACK_VERSION; } });
+var resolveOptions_1 = require("./resolveOptions");
+Object.defineProperty(exports, "resolveOptions", { enumerable: true, get: function () { return __importDefault(resolveOptions_1).default; } });
+var Environment_1 = require("./Environment");
+Object.defineProperty(exports, "createEnvironment", { enumerable: true, get: function () { return Environment_1.createEnvironment; } });
+var Environment_2 = require("./public/Environment");
+Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return __importDefault(Environment_2).default; } });
+__exportStar(require("./atlaspack-v3"), exports);

package/dist/loadAtlaspackPlugin.js

@@ -0,0 +1,128 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadPlugin;
+const path_1 = __importDefault(require("path"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const utils_1 = require("@atlaspack/utils");
+const projectPath_1 = require("./projectPath");
+const NODE_MODULES = `${path_1.default.sep}node_modules${path_1.default.sep}`;
+const CONFIG = Symbol.for('parcel-plugin-config');
+async function loadPlugin(pluginName, configPath, keyPath, options) {
+    let resolveFrom = configPath;
+    // Config packages can reference plugins, but cannot contain other plugins within them.
+    // This forces every published plugin to be published separately so they can be mixed and matched if needed.
+    if (resolveFrom.includes(NODE_MODULES) && pluginName.startsWith('.')) {
+        let configContents = await options.inputFS.readFile(configPath, 'utf8');
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: (0, diagnostic_1.md) `Local plugins are not supported in Atlaspack config packages. Please publish "${pluginName}" as a separate npm package.`,
+                origin: '@atlaspack/core',
+                codeFrames: keyPath
+                    ? [
+                        {
+                            filePath: configPath,
+                            language: 'json5',
+                            code: configContents,
+                            codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(configContents, [
+                                {
+                                    key: keyPath,
+                                    type: 'value',
+                                },
+                            ]),
+                        },
+                    ]
+                    : undefined,
+            },
+        });
+    }
+    let pkg;
+    try {
+        ({ pkg } = await options.packageManager.resolve(pluginName, resolveFrom, {
+            shouldAutoInstall: options.shouldAutoInstall,
+        }));
+    }
+    catch (err) {
+        if (err.code !== 'MODULE_NOT_FOUND') {
+            throw err;
+        }
+        let configContents = await options.inputFS.readFile(configPath, 'utf8');
+        let alternatives = await (0, utils_1.findAlternativeNodeModules)(options.inputFS, pluginName, path_1.default.dirname(resolveFrom));
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: (0, diagnostic_1.md) `Cannot find Atlaspack plugin "${pluginName}"`,
+                origin: '@atlaspack/core',
+                codeFrames: keyPath
+                    ? [
+                        {
+                            filePath: configPath,
+                            language: 'json5',
+                            code: configContents,
+                            codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(configContents, [
+                                {
+                                    key: keyPath,
+                                    type: 'value',
+                                    message: (0, diagnostic_1.md) `Cannot find module "${pluginName}"${alternatives[0]
+                                        ? `, did you mean "${alternatives[0]}"?`
+                                        : ''}`,
+                                },
+                            ]),
+                        },
+                    ]
+                    : undefined,
+            },
+        });
+    }
+    let plugin = await options.packageManager.require(pluginName, resolveFrom, {
+        shouldAutoInstall: options.shouldAutoInstall,
+    });
+    plugin = plugin.default ? plugin.default : plugin;
+    if (!plugin) {
+        throw new Error(`Plugin ${pluginName} has no exports.`);
+    }
+    plugin = plugin[CONFIG];
+    if (!plugin) {
+        throw new Error(`Plugin ${pluginName} is not a valid Atlaspack plugin, should export an instance of a Atlaspack plugin ex. "export default new Reporter({ ... })".`);
+    }
+    return {
+        plugin,
+        version: (0, nullthrows_1.default)(pkg).version,
+        resolveFrom: (0, projectPath_1.toProjectPath)(options.projectRoot, resolveFrom),
+    };
+}

package/dist/loadDotEnv.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadEnv;
+const utils_1 = require("@atlaspack/utils");
+const dotenv_1 = __importDefault(require("dotenv"));
+const dotenv_expand_1 = __importDefault(require("dotenv-expand"));
+async function loadEnv(env, fs, filePath, projectRoot) {
+    const NODE_ENV = env.NODE_ENV ?? 'development';
+    const dotenvFiles = [
+        '.env',
+        // Don't include `.env.local` for `test` environment
+        // since normally you expect tests to produce the same
+        // results for everyone
+        NODE_ENV === 'test' ? null : '.env.local',
+        `.env.${NODE_ENV}`,
+        `.env.${NODE_ENV}.local`,
+    ].filter(Boolean);
+    let envs = await Promise.all(dotenvFiles.map(async (dotenvFile) => {
+        const envPath = await (0, utils_1.resolveConfig)(fs, filePath, 
+        // @ts-expect-error TS2322
+        [dotenvFile], projectRoot);
+        if (envPath == null) {
+            return;
+        }
+        // `ignoreProcessEnv` prevents dotenv-expand from writing values into `process.env`:
+        // https://github.com/motdotla/dotenv-expand/blob/ddb73d02322fe8522b4e05b73e1c1ad24ea7c14a/lib/main.js#L5
+        let output = (0, dotenv_expand_1.default)({
+            parsed: dotenv_1.default.parse(await fs.readFile(envPath)),
+            // @ts-expect-error TS2353
+            ignoreProcessEnv: true,
+        });
+        if (output.error != null) {
+            throw output.error;
+        }
+        return output.parsed;
+    }));
+    return Object.assign({}, ...envs);
+}

package/dist/projectPath.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromProjectPath = exports.toProjectPath = void 0;
+exports.fromProjectPathRelative = fromProjectPathRelative;
+exports.toProjectPathUnsafe = toProjectPathUnsafe;
+exports.joinProjectPath = joinProjectPath;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@atlaspack/utils");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+/**
+ * Converts a file path to a project-relative path.
+ *
+ * @param projectRoot - The project root.
+ * @param p - The file path to convert.
+ * @returns The project path.
+ */
+function toProjectPath_(projectRoot, p) {
+    // If the file path is not provided, then treat it as though it is already from the project root
+    if (p == null) {
+        return p;
+    }
+    // If the file path is already relative and it does not begin with '.', then treat the path as if it
+    // is already from the project root. This prevents relative paths from being processed twice,
+    // most often within `toInternalSourceLocation` when handling loc types from symbols and asset
+    // dependencies.
+    if (p[0] !== '.' && !path_1.default.isAbsolute(p)) {
+        return p;
+    }
+    // If the file is outside the project root, store an absolute path rather than a relative one.
+    // This way if the project root is moved, the file references still work. Accessing files outside
+    // the project root is not portable anyway.
+    let relative = (0, utils_1.relativePath)(projectRoot, p, false);
+    if (relative.startsWith('..')) {
+        // e.g given projectRoot = '/Users/monorepo/project' and p = '/Users/monorepo/other-project/src/index.js' --> relative = '../other-project/src/index.js'
+        if ((0, feature_flags_1.getFeatureFlagValue)('patchProjectPaths')) {
+            return relative;
+        }
+        return process.platform === 'win32' ? (0, utils_1.normalizeSeparators)(p) : p;
+    }
+    return relative;
+}
+// @ts-expect-error TS2322
+exports.toProjectPath = toProjectPath_;
+function fromProjectPath_(projectRoot, p) {
+    if (p == null) {
+        return null;
+    }
+    // Project paths use normalized unix separators, so we only need to
+    // convert them on Windows.
+    let projectPath = process.platform === 'win32' ? path_1.default.normalize(p) : p;
+    // If the path is absolute (e.g. outside the project root), just return it.
+    if (path_1.default.isAbsolute(projectPath)) {
+        return projectPath;
+    }
+    // Add separator if needed. Doing this manunally is much faster than path.join.
+    if (projectRoot[projectRoot.length - 1] !== path_1.default.sep) {
+        return projectRoot + path_1.default.sep + projectPath;
+    }
+    return projectRoot + projectPath;
+}
+// @ts-expect-error TS2322
+exports.fromProjectPath = fromProjectPath_;
+/**
+ * Returns a path relative to the project root. This should be used when computing cache keys
+ */
+function fromProjectPathRelative(p) {
+    return p;
+}
+/**
+ * This function should be avoided, it doesn't change the actual value.
+ */
+function toProjectPathUnsafe(p) {
+    return p;
+}
+/**
+ * Joins a project root with relative paths (similar to `path.join`)
+ */
+function joinProjectPath(a, ...b) {
+    return path_1.default.posix.join(a, ...b);
+}

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();