@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/dist/atlaspack-v3/NapiWorkerPool.js

@@ -0,0 +1,114 @@
+"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 _NapiWorkerPool_workers, _NapiWorkerPool_napiWorkers, _NapiWorkerPool_workerCount;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NapiWorkerPool = void 0;
+const worker_threads_1 = require("worker_threads");
+const path_1 = __importDefault(require("path"));
+const process_1 = __importDefault(require("process"));
+const rust_1 = require("@atlaspack/rust");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const WORKER_PATH = path_1.default.join(__dirname, 'worker', 'index.js');
+const ATLASPACK_NAPI_WORKERS = process_1.default.env.ATLASPACK_NAPI_WORKERS &&
+    parseInt(process_1.default.env.ATLASPACK_NAPI_WORKERS, 10);
+class NapiWorkerPool {
+    constructor({ workerCount } = { workerCount: undefined }) {
+        _NapiWorkerPool_workers.set(this, void 0);
+        _NapiWorkerPool_napiWorkers.set(this, void 0);
+        _NapiWorkerPool_workerCount.set(this, void 0);
+        // @ts-expect-error TS2322
+        __classPrivateFieldSet(this, _NapiWorkerPool_workerCount, workerCount ??
+            ATLASPACK_NAPI_WORKERS ??
+            // Default to a maximum of 4 workers as performance worsens beyond that
+            // point in most cases
+            Math.min((0, rust_1.getAvailableThreads)(), 4), "f");
+        if (!__classPrivateFieldGet(this, _NapiWorkerPool_workerCount, "f")) {
+            // TODO use main thread if workerCount is 0
+        }
+        __classPrivateFieldSet(this, _NapiWorkerPool_workers, [], "f");
+        __classPrivateFieldSet(this, _NapiWorkerPool_napiWorkers, [], "f");
+        for (let i = 0; i < __classPrivateFieldGet(this, _NapiWorkerPool_workerCount, "f"); i++) {
+            let worker = new worker_threads_1.Worker(WORKER_PATH);
+            __classPrivateFieldGet(this, _NapiWorkerPool_workers, "f").push(worker);
+            __classPrivateFieldGet(this, _NapiWorkerPool_napiWorkers, "f").push(new Promise((res) => worker.once('message', res)));
+            // Re-emit log events from the worker thread into the main-thread logger
+            // so they reach reporters and are subject to log-level filtering.
+            worker.on('message', (message) => {
+                if (message != null &&
+                    typeof message === 'object' &&
+                    message.type === 'logEvent') {
+                    const event = message.event;
+                    switch (event.level) {
+                        case 'verbose':
+                            logger_1.default.verbose(event.diagnostics);
+                            break;
+                        case 'info':
+                            logger_1.default.info(event.diagnostics);
+                            break;
+                        case 'warn':
+                            logger_1.default.warn(event.diagnostics);
+                            break;
+                        case 'error':
+                            logger_1.default.error(event.diagnostics);
+                            break;
+                        case 'progress':
+                            logger_1.default.progress(event.message);
+                            break;
+                    }
+                }
+            });
+        }
+    }
+    clearAllWorkerState() {
+        return Promise.all(__classPrivateFieldGet(this, _NapiWorkerPool_workers, "f").map((worker) => new Promise((res) => {
+            worker.postMessage('clearState');
+            // Set up a message handler that only resolves on 'stateCleared'
+            // and ignores all other messages (like the initial napiWorker Transferable)
+            const messageHandler = (message) => {
+                if (message === 'stateCleared') {
+                    worker.removeListener('message', messageHandler);
+                    res();
+                }
+                else if (message != null &&
+                    typeof message === 'object' &&
+                    message.type === 'logEvent') {
+                    // logEvent messages are forwarded asynchronously from the worker
+                    // logger bridge and are expected at any time; ignore them here.
+                }
+                else {
+                    // Log unexpected messages for debugging
+                    // eslint-disable-next-line no-console
+                    console.warn(`[NapiWorkerPool] Received unexpected message during clearAllWorkerState: ${JSON.stringify(message)} (type: ${typeof message})`);
+                    // Keep listening for 'stateCleared' - don't remove the listener
+                }
+            };
+            worker.on('message', messageHandler);
+        })));
+    }
+    workerCount() {
+        return __classPrivateFieldGet(this, _NapiWorkerPool_workerCount, "f");
+    }
+    getWorkers() {
+        return Promise.all(__classPrivateFieldGet(this, _NapiWorkerPool_napiWorkers, "f"));
+    }
+    shutdown() {
+        for (const worker of __classPrivateFieldGet(this, _NapiWorkerPool_workers, "f")) {
+            worker.terminate();
+        }
+    }
+}
+exports.NapiWorkerPool = NapiWorkerPool;
+_NapiWorkerPool_workers = new WeakMap(), _NapiWorkerPool_napiWorkers = new WeakMap(), _NapiWorkerPool_workerCount = new WeakMap();

package/dist/atlaspack-v3/fs.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 _FileSystemV3_fs;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemV3 = void 0;
+const jsCallable_1 = require("./jsCallable");
+// @ts-expect-error TS2420
+class FileSystemV3 {
+    constructor(fs) {
+        _FileSystemV3_fs.set(this, void 0);
+        this.canonicalize = (0, jsCallable_1.jsCallable)((path) => __classPrivateFieldGet(this, _FileSystemV3_fs, "f").realpathSync(path));
+        this.createDirectory = (0, jsCallable_1.jsCallable)((path) => __classPrivateFieldGet(this, _FileSystemV3_fs, "f").mkdirp(path));
+        this.cwd = (0, jsCallable_1.jsCallable)(() => __classPrivateFieldGet(this, _FileSystemV3_fs, "f").cwd());
+        this.isFile = (path) => {
+            try {
+                return __classPrivateFieldGet(this, _FileSystemV3_fs, "f").statSync(path).isFile();
+            }
+            catch {
+                return false;
+            }
+        };
+        this.isDir = (path) => {
+            try {
+                return __classPrivateFieldGet(this, _FileSystemV3_fs, "f").statSync(path).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        };
+        this.readFile = (0, jsCallable_1.jsCallable)((path, encoding) => {
+            if (!encoding) {
+                return [...__classPrivateFieldGet(this, _FileSystemV3_fs, "f").readFileSync(path)];
+            }
+            else {
+                return __classPrivateFieldGet(this, _FileSystemV3_fs, "f").readFileSync(path, encoding);
+            }
+        });
+        this.writeFile = (0, jsCallable_1.jsCallable)((path, contents) => __classPrivateFieldGet(this, _FileSystemV3_fs, "f").writeFile(path, Buffer.from(contents)));
+        __classPrivateFieldSet(this, _FileSystemV3_fs, fs, "f");
+    }
+}
+exports.FileSystemV3 = FileSystemV3;
+_FileSystemV3_fs = new WeakMap();

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,98 @@
+"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);
+        _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);
+    }
+    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);
+    }
+    toArray(keys) {
+        let values = [];
+        for (let [key, value] of Object.entries(__classPrivateFieldGet(this, _BitFlags_kv, "f"))) {
+            if ((keys & value) !== 0) {
+                values.push(key);
+            }
+        }
+        return values;
+    }
+}
+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,
+});
+// Note: The bitflags must match the bitflags in the Rust code.
+// crates/atlaspack_core/src/types/package_json.rs
+exports.packageConditionsMap = new BitFlags({
+    import: 1 << 0,
+    require: 1 << 1,
+    module: 1 << 2,
+    node: 1 << 3,
+    browser: 1 << 4,
+    worker: 1 << 5,
+    worklet: 1 << 6,
+    electron: 1 << 7,
+    development: 1 << 8,
+    production: 1 << 9,
+    types: 1 << 10,
+    default: 1 << 11,
+    style: 1 << 12,
+    sass: 1 << 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.toArray(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,24 @@
+"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-options"), exports);
+__exportStar(require("./mutable-asset"), exports);