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

package/dist/atlaspack-v3/index.js

@@ -0,0 +1,25 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NapiWorkerPool = exports.AtlaspackV3 = exports.FileSystemV3 = void 0;
+var fs_1 = require("./fs");
+Object.defineProperty(exports, "FileSystemV3", { enumerable: true, get: function () { return fs_1.FileSystemV3; } });
+var AtlaspackV3_1 = require("./AtlaspackV3");
+Object.defineProperty(exports, "AtlaspackV3", { enumerable: true, get: function () { return AtlaspackV3_1.AtlaspackV3; } });
+var NapiWorkerPool_1 = require("./NapiWorkerPool");
+Object.defineProperty(exports, "NapiWorkerPool", { enumerable: true, get: function () { return NapiWorkerPool_1.NapiWorkerPool; } });
+__exportStar(require("./AtlaspackV3"), exports);
+__exportStar(require("./NapiWorkerPool"), exports);

package/dist/atlaspack-v3/jsCallable.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsCallable = jsCallable;
+function jsCallable(fn) {
+    return async (...args) => {
+        try {
+            // Promises and is safe to use on non-promises
+            return await fn(...args);
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error(error);
+            throw error;
+        }
+    };
+}

package/dist/atlaspack-v3/worker/compat/asset-symbols.js

@@ -0,0 +1,190 @@
+"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 _MutableDependencySymbols_symbols, _MutableDependencySymbols_locals, _AssetSymbols_instances, _AssetSymbols_symbols, _AssetSymbols_locals, _AssetSymbols_set, _MutableAssetSymbols_symbols, _MutableAssetSymbols_locals;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableAssetSymbols = exports.AssetSymbols = exports.MutableDependencySymbols = void 0;
+class MutableDependencySymbols {
+    get isCleared() {
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_symbols, "f").size === 0;
+    }
+    constructor(inner) {
+        _MutableDependencySymbols_symbols.set(this, void 0);
+        _MutableDependencySymbols_locals.set(this, void 0);
+        __classPrivateFieldSet(this, _MutableDependencySymbols_symbols, new Map(), "f");
+        __classPrivateFieldSet(this, _MutableDependencySymbols_locals, new Set(), "f");
+        for (const { exported, local, loc, isWeak } of inner || []) {
+            this.set(exported, local, loc, isWeak);
+        }
+    }
+    ensure() {
+        throw new Error('MutableDependencySymbols.ensure()');
+    }
+    get(exportSymbol) {
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_symbols, "f").get(exportSymbol);
+    }
+    hasExportSymbol(exportSymbol) {
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_symbols, "f").has(exportSymbol);
+    }
+    hasLocalSymbol(local) {
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_locals, "f").has(local);
+    }
+    exportSymbols() {
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_symbols, "f").keys();
+    }
+    set(exportSymbol, local, loc, isWeak) {
+        __classPrivateFieldGet(this, _MutableDependencySymbols_locals, "f").add(local);
+        __classPrivateFieldGet(this, _MutableDependencySymbols_symbols, "f").set(exportSymbol, {
+            local,
+            loc,
+            meta: {},
+            isWeak: isWeak ?? false,
+        });
+    }
+    delete(exportSymbol) {
+        let existing = __classPrivateFieldGet(this, _MutableDependencySymbols_symbols, "f").get(exportSymbol);
+        if (!existing)
+            return;
+        __classPrivateFieldGet(this, _MutableDependencySymbols_locals, "f").delete(existing.local);
+        __classPrivateFieldGet(this, _MutableDependencySymbols_symbols, "f").delete(exportSymbol);
+    }
+    /*::  @@iterator(): Iterator<[Symbol, DependencyAssetSymbol]> { return ({}: any); } */
+    // @ts-expect-error TS2416
+    [(_MutableDependencySymbols_symbols = new WeakMap(), _MutableDependencySymbols_locals = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_symbols, "f").values();
+    }
+}
+exports.MutableDependencySymbols = MutableDependencySymbols;
+class AssetSymbols {
+    get isCleared() {
+        return __classPrivateFieldGet(this, _AssetSymbols_symbols, "f").size === 0;
+    }
+    constructor(inner) {
+        _AssetSymbols_instances.add(this);
+        _AssetSymbols_symbols.set(this, void 0);
+        _AssetSymbols_locals.set(this, void 0);
+        __classPrivateFieldSet(this, _AssetSymbols_symbols, new Map(), "f");
+        __classPrivateFieldSet(this, _AssetSymbols_locals, new Set(), "f");
+        for (const { exported, local, loc } of inner || []) {
+            __classPrivateFieldGet(this, _AssetSymbols_instances, "m", _AssetSymbols_set).call(this, exported, local, loc);
+        }
+    }
+    get(exportSymbol) {
+        return __classPrivateFieldGet(this, _AssetSymbols_symbols, "f").get(exportSymbol);
+    }
+    hasExportSymbol(exportSymbol) {
+        return __classPrivateFieldGet(this, _AssetSymbols_symbols, "f").has(exportSymbol);
+    }
+    hasLocalSymbol(local) {
+        return __classPrivateFieldGet(this, _AssetSymbols_locals, "f").has(local);
+    }
+    exportSymbols() {
+        return __classPrivateFieldGet(this, _AssetSymbols_symbols, "f").keys();
+    }
+    intoNapi() {
+        return [];
+    }
+    /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
+    // @ts-expect-error TS2416
+    [(_AssetSymbols_symbols = new WeakMap(), _AssetSymbols_locals = new WeakMap(), _AssetSymbols_instances = new WeakSet(), _AssetSymbols_set = function _AssetSymbols_set(exportSymbol, local, loc) {
+        __classPrivateFieldGet(this, _AssetSymbols_locals, "f").add(local);
+        __classPrivateFieldGet(this, _AssetSymbols_symbols, "f").set(exportSymbol, {
+            local,
+            loc,
+            meta: {},
+        });
+    }, Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _AssetSymbols_symbols, "f").values();
+    }
+}
+exports.AssetSymbols = AssetSymbols;
+class MutableAssetSymbols {
+    get isCleared() {
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").size === 0;
+    }
+    constructor(inner) {
+        _MutableAssetSymbols_symbols.set(this, void 0);
+        _MutableAssetSymbols_locals.set(this, void 0);
+        __classPrivateFieldSet(this, _MutableAssetSymbols_symbols, new Map(), "f");
+        __classPrivateFieldSet(this, _MutableAssetSymbols_locals, new Set(), "f");
+        for (const { exported, loc, local, isEsmExport, selfReferenced, isStaticBindingSafe, } of inner || []) {
+            this.set(exported, local, loc, {
+                isEsm: isEsmExport,
+                isStaticBindingSafe,
+                selfReferenced,
+            });
+        }
+    }
+    intoNapi() {
+        const results = [];
+        for (const [exportSymbol, { local, loc, meta }] of __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").entries()) {
+            results.push({
+                exported: exportSymbol,
+                local,
+                loc: loc
+                    ? {
+                        filePath: loc.filePath,
+                        start: {
+                            line: loc.start.line,
+                            column: loc.start.column,
+                        },
+                        end: {
+                            line: loc.end.line,
+                            column: loc.end.column,
+                        },
+                    }
+                    : undefined,
+                isEsmExport: Boolean(meta?.isEsm),
+                isStaticBindingSafe: Boolean(meta?.isStaticBindingSafe),
+                isWeak: false,
+                selfReferenced: Boolean(meta?.selfReferenced),
+            });
+        }
+        return results;
+    }
+    ensure() {
+        throw new Error('MutableAssetSymbols.ensure()');
+    }
+    set(exportSymbol, local, loc, meta) {
+        __classPrivateFieldGet(this, _MutableAssetSymbols_locals, "f").add(local);
+        __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").set(exportSymbol, {
+            local,
+            loc,
+            meta,
+        });
+    }
+    get(exportSymbol) {
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").get(exportSymbol);
+    }
+    hasExportSymbol(exportSymbol) {
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").has(exportSymbol);
+    }
+    hasLocalSymbol(local) {
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_locals, "f").has(local);
+    }
+    exportSymbols() {
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").keys();
+    }
+    delete(exportSymbol) {
+        let existing = __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").get(exportSymbol);
+        if (!existing)
+            return;
+        __classPrivateFieldGet(this, _MutableAssetSymbols_locals, "f").delete(existing.local);
+        __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").delete(exportSymbol);
+    }
+    /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
+    // @ts-expect-error TS2416
+    [(_MutableAssetSymbols_symbols = new WeakMap(), _MutableAssetSymbols_locals = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_symbols, "f").values();
+    }
+}
+exports.MutableAssetSymbols = MutableAssetSymbols;

package/dist/atlaspack-v3/worker/compat/bitflags.js

@@ -0,0 +1,94 @@
+"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 _BitFlags_kv, _BitFlags_vk;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specifierTypeMap = exports.packageConditionsMap = exports.dependencyPriorityMap = exports.bundleBehaviorMap = exports.BitFlags = void 0;
+/// BitFlags is used to map number/string types from napi types
+class BitFlags {
+    // @ts-expect-error TS2344
+    constructor(source) {
+        // @ts-expect-error TS2344
+        _BitFlags_kv.set(this, void 0);
+        // @ts-expect-error TS2344
+        _BitFlags_vk.set(this, void 0);
+        __classPrivateFieldSet(this, _BitFlags_kv, source, "f");
+        __classPrivateFieldSet(this, _BitFlags_vk, Object.fromEntries(Object.entries(source).map((a) => a.reverse())), "f");
+    }
+    into(key) {
+        const found = __classPrivateFieldGet(this, _BitFlags_kv, "f")[key];
+        if (found === undefined) {
+            throw new Error(`Invalid BundleBehavior(${key})`);
+        }
+        return found;
+    }
+    intoNullable(key) {
+        if (key === undefined || key === null) {
+            return undefined;
+        }
+        return this.into(key);
+    }
+    intoArray(keys) {
+        return keys.map((key) => this.into(key));
+    }
+    from(key) {
+        const found = __classPrivateFieldGet(this, _BitFlags_vk, "f")[key];
+        if (found === undefined) {
+            throw new Error(`Invalid BundleBehavior(${key})`);
+        }
+        return found;
+    }
+    fromNullable(key) {
+        if (key === undefined || key === null) {
+            return undefined;
+        }
+        return this.from(key);
+    }
+    fromArray(keys) {
+        return keys.map((key) => this.from(key));
+    }
+}
+exports.BitFlags = BitFlags;
+_BitFlags_kv = new WeakMap(), _BitFlags_vk = new WeakMap();
+exports.bundleBehaviorMap = new BitFlags({
+    inline: 0,
+    isolated: 1,
+    inlineIsolated: 2,
+});
+exports.dependencyPriorityMap = new BitFlags({
+    sync: 0,
+    parallel: 1,
+    lazy: 2,
+    conditional: 3,
+});
+exports.packageConditionsMap = new BitFlags({
+    import: 0,
+    require: 1,
+    module: 2,
+    node: 3,
+    browser: 4,
+    worker: 5,
+    worklet: 6,
+    electron: 7,
+    development: 8,
+    production: 9,
+    types: 10,
+    default: 11,
+    style: 12,
+    sass: 13,
+});
+exports.specifierTypeMap = new BitFlags({
+    esm: 0,
+    commonjs: 1,
+    url: 2,
+    custom: 3,
+});

package/dist/atlaspack-v3/worker/compat/dependency.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dependency = void 0;
+const target_1 = require("./target");
+const asset_symbols_1 = require("./asset-symbols");
+const bitflags_1 = require("./bitflags");
+class Dependency {
+    get id() {
+        throw new Error('Dependency.id');
+    }
+    constructor(inner, env) {
+        this.env = env;
+        this.meta = inner.meta || {};
+        this.target = undefined;
+        if (inner.target) {
+            this.target = new target_1.Target(inner.target, this.env);
+        }
+        if (!inner.bundleBehavior) {
+            this.bundleBehavior = undefined;
+        }
+        else {
+            this.bundleBehavior = bitflags_1.bundleBehaviorMap.from(inner.bundleBehavior);
+        }
+        this.bundleBehavior = undefined;
+        // @ts-expect-error TS2322
+        this.symbols = new asset_symbols_1.MutableDependencySymbols(inner.symbols || []);
+        this.specifier = inner.specifier;
+        this.specifierType = bitflags_1.specifierTypeMap.from(inner.specifierType);
+        this.priority = bitflags_1.dependencyPriorityMap.from(inner.priority);
+        this.needsStableName = inner.needsStableName;
+        this.isOptional = inner.isOptional;
+        this.isEntry = inner.isEntry;
+        this.loc = inner.loc;
+        this.packageConditions = bitflags_1.packageConditionsMap.fromArray(inner.packageConditions || []);
+        this.sourceAssetId = inner.sourceAssetId;
+        this.sourcePath = inner.sourcePath;
+        this.sourceAssetType = inner.sourceAssetType;
+        this.resolveFrom = inner.resolveFrom ?? inner.sourcePath;
+        this.range = inner.range;
+        this.pipeline = inner.pipeline;
+    }
+}
+exports.Dependency = Dependency;

package/dist/atlaspack-v3/worker/compat/environment.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = void 0;
+class Environment {
+    constructor(inner) {
+        // TODO
+        this.id = '';
+        this.includeNodeModules = inner.includeNodeModules;
+        this.context = inner.context;
+        this.engines = inner.engines;
+        this.outputFormat = inner.outputFormat;
+        this.sourceType = inner.sourceType;
+        this.isLibrary = inner.isLibrary;
+        this.shouldOptimize = inner.shouldOptimize;
+        this.shouldScopeHoist = inner.shouldScopeHoist;
+        this.sourceMap = inner.sourceMap;
+        this.loc = inner.loc;
+        this.unstableSingleFileOutput = false;
+        this.customEnv = inner.customEnv;
+    }
+    isBrowser() {
+        return (this.context === 'browser' ||
+            this.isWorker() ||
+            this.isTesseract() ||
+            this.isWorklet() ||
+            this.context === 'electron-renderer');
+    }
+    isNode() {
+        return this.context === 'node' || this.isElectron();
+    }
+    isElectron() {
+        return (this.context === 'electron-main' || this.context === 'electron-renderer');
+    }
+    isWorker() {
+        return this.context === 'web-worker' || this.context === 'service-worker';
+    }
+    isWorklet() {
+        return this.context === 'worklet';
+    }
+    isTesseract() {
+        return this.context === 'tesseract';
+    }
+    isIsolated() {
+        return this.isWorker() || this.isTesseract() || this.isWorklet();
+    }
+    // TODO
+    // eslint-disable-next-line no-unused-vars
+    matchesEngines(minVersions, defaultValue) {
+        return true;
+    }
+    // TODO
+    // eslint-disable-next-line no-unused-vars
+    supports(feature, defaultValue) {
+        return true;
+    }
+}
+exports.Environment = Environment;

package/dist/atlaspack-v3/worker/compat/index.js

@@ -0,0 +1,25 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bitflags"), exports);
+__exportStar(require("./dependency"), exports);
+__exportStar(require("./environment"), exports);
+__exportStar(require("./target"), exports);
+__exportStar(require("./plugin-config"), exports);
+__exportStar(require("./plugin-tracer"), exports);
+__exportStar(require("./plugin-logger"), exports);
+__exportStar(require("./plugin-options"), exports);
+__exportStar(require("./mutable-asset"), exports);

package/dist/atlaspack-v3/worker/compat/mutable-asset.js

@@ -0,0 +1,152 @@
+"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 _MutableAsset_astDirty, _MutableAsset_ast, _MutableAsset_contents, _MutableAsset_inner, _MutableAsset_map, _MutableAsset_projectRoot, _MutableAsset_sourceMap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableAsset = void 0;
+const source_map_1 = __importDefault(require("@parcel/source-map"));
+const stream_1 = require("stream");
+const bitflags_1 = require("./bitflags");
+const asset_symbols_1 = require("./asset-symbols");
+class MutableAsset {
+    get astGenerator() {
+        throw new Error('get MutableAsset.astGenerator');
+    }
+    // @ts-expect-error TS1051
+    set astGenerator(value) {
+        throw new Error('set MutableAsset.astGenerator');
+    }
+    constructor(asset, contents, env, fs, map, projectRoot) {
+        _MutableAsset_astDirty.set(this, void 0);
+        _MutableAsset_ast.set(this, void 0);
+        _MutableAsset_contents.set(this, void 0);
+        _MutableAsset_inner.set(this, void 0);
+        _MutableAsset_map.set(this, void 0);
+        _MutableAsset_projectRoot.set(this, void 0);
+        _MutableAsset_sourceMap.set(this, void 0);
+        this.bundleBehavior = bitflags_1.bundleBehaviorMap.fromNullable(asset.bundleBehavior);
+        this.env = env;
+        this.filePath = asset.filePath;
+        this.fs = fs;
+        this.id = asset.id;
+        this.isBundleSplittable = asset.isBundleSplittable;
+        this.isSource = asset.isSource;
+        this.meta = asset.meta;
+        this.pipeline = asset.pipeline;
+        this.query = new URLSearchParams(asset.query);
+        this.sideEffects = asset.sideEffects;
+        this.stats = asset.stats;
+        this.symbols = new asset_symbols_1.MutableAssetSymbols(asset.symbols);
+        this.type = asset.type;
+        this.uniqueKey = asset.uniqueKey;
+        __classPrivateFieldSet(this, _MutableAsset_astDirty, false, "f");
+        __classPrivateFieldSet(this, _MutableAsset_contents, contents, "f");
+        __classPrivateFieldSet(this, _MutableAsset_inner, asset, "f");
+        __classPrivateFieldSet(this, _MutableAsset_map, map, "f");
+        __classPrivateFieldSet(this, _MutableAsset_projectRoot, projectRoot, "f");
+    }
+    // eslint-disable-next-line require-await
+    async getAST() {
+        return __classPrivateFieldGet(this, _MutableAsset_ast, "f");
+    }
+    setAST(ast) {
+        __classPrivateFieldSet(this, _MutableAsset_astDirty, true, "f");
+        __classPrivateFieldSet(this, _MutableAsset_ast, ast, "f");
+    }
+    isASTDirty() {
+        return __classPrivateFieldGet(this, _MutableAsset_astDirty, "f");
+    }
+    // eslint-disable-next-line require-await
+    async getCode() {
+        return __classPrivateFieldGet(this, _MutableAsset_contents, "f").toString();
+    }
+    setCode(code) {
+        __classPrivateFieldSet(this, _MutableAsset_contents, Buffer.from(code), "f");
+    }
+    // eslint-disable-next-line require-await
+    async getBuffer() {
+        return __classPrivateFieldGet(this, _MutableAsset_contents, "f");
+    }
+    setBuffer(buf) {
+        __classPrivateFieldSet(this, _MutableAsset_contents, buf, "f");
+    }
+    getStream() {
+        return stream_1.Readable.from(__classPrivateFieldGet(this, _MutableAsset_contents, "f"));
+    }
+    setStream(stream) {
+        const data = [];
+        stream.on('data', (chunk) => {
+            data.push(chunk);
+        });
+        stream.on('end', () => {
+            __classPrivateFieldSet(this, _MutableAsset_contents, Buffer.concat(data), "f");
+        });
+        stream.on('error', () => {
+            throw new Error('MutableAsset.setStream()');
+        });
+    }
+    getMap() {
+        // Only create the source map if it is requested
+        if (!__classPrivateFieldGet(this, _MutableAsset_sourceMap, "f") && __classPrivateFieldGet(this, _MutableAsset_map, "f") && typeof __classPrivateFieldGet(this, _MutableAsset_map, "f") === 'string') {
+            let sourceMap = new source_map_1.default(__classPrivateFieldGet(this, _MutableAsset_projectRoot, "f"));
+            sourceMap.addVLQMap(JSON.parse(__classPrivateFieldGet(this, _MutableAsset_map, "f")));
+            __classPrivateFieldSet(this, _MutableAsset_sourceMap, sourceMap, "f");
+        }
+        return Promise.resolve(__classPrivateFieldGet(this, _MutableAsset_sourceMap, "f"));
+    }
+    // eslint-disable-next-line no-unused-vars
+    setMap(sourceMap) {
+        this.isMapDirty = true;
+        __classPrivateFieldSet(this, _MutableAsset_sourceMap, sourceMap, "f");
+    }
+    getMapBuffer() {
+        throw new Error('getMapBuffer() is considered an internal implementation detail, please use getMap() instead');
+    }
+    getDependencies() {
+        throw new Error('MutableAsset.getDependencies');
+    }
+    // eslint-disable-next-line no-unused-vars
+    addDependency(options) {
+        throw new Error('MutableAsset.addDependency()');
+    }
+    // eslint-disable-next-line no-unused-vars
+    addURLDependency(url, opts) {
+        throw new Error('MutableAsset.addURLDependency()');
+    }
+    // eslint-disable-next-line no-unused-vars
+    setEnvironment(opts) {
+        throw new Error('MutableAsset.setEnvironment()');
+    }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnFileChange(invalidation) {
+        // TODO: Forward invalidations to Rust
+    }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnFileCreate(invalidation) {
+        // TODO: Forward invalidations to Rust
+    }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnEnvChange(invalidation) {
+        // TODO: Forward invalidations to Rust
+    }
+    invalidateOnStartup() {
+        // TODO: Forward invalidations to Rust
+    }
+    invalidateOnBuild() {
+        // TODO: Forward invalidations to Rust
+    }
+}
+exports.MutableAsset = MutableAsset;
+_MutableAsset_astDirty = new WeakMap(), _MutableAsset_ast = new WeakMap(), _MutableAsset_contents = new WeakMap(), _MutableAsset_inner = new WeakMap(), _MutableAsset_map = new WeakMap(), _MutableAsset_projectRoot = new WeakMap(), _MutableAsset_sourceMap = new WeakMap();