@wyw-in-js/transform 0.1.0

package/types/debug/fileReporter.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileReporter = void 0;
+/* eslint-disable no-console */
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const EventEmitter_1 = require("../utils/EventEmitter");
+const workingDir = process.cwd();
+function replacer(_key, value) {
+    if (typeof value === 'string' && path_1.default.isAbsolute(value)) {
+        return path_1.default.relative(workingDir, value);
+    }
+    if (value instanceof Map) {
+        return Array.from(value.entries()).reduce((obj, [k, v]) => {
+            const key = replacer(k, k);
+            return {
+                ...obj,
+                [key]: replacer(key, v),
+            };
+        }, {});
+    }
+    return value;
+}
+function printTimings(timings, startedAt, sourceRoot) {
+    if (timings.size === 0) {
+        return;
+    }
+    console.log(`\nTimings:`);
+    console.log(`  Total: ${(performance.now() - startedAt).toFixed()}ms`);
+    Array.from(timings.entries()).forEach(([label, byLabel]) => {
+        console.log(`\n  By ${label}:`);
+        const array = Array.from(byLabel.entries());
+        // array.sort(([, a], [, b]) => b - a);
+        array
+            .sort(([a], [b]) => a.localeCompare(b))
+            .forEach(([value, time]) => {
+            const name = value.startsWith(sourceRoot)
+                ? path_1.default.relative(sourceRoot, value)
+                : value;
+            console.log(`    ${name}: ${time}ms`);
+        });
+    });
+}
+const writeJSONl = (stream, data) => {
+    stream.write(`${JSON.stringify(data, replacer)}\n`);
+};
+const createFileReporter = (options = false) => {
+    if (!options || !options.dir) {
+        return {
+            emitter: EventEmitter_1.EventEmitter.dummy,
+            onDone: () => { },
+        };
+    }
+    const reportFolder = (0, fs_1.existsSync)(options.dir)
+        ? options.dir
+        : (0, fs_1.mkdirSync)(options.dir, {
+            recursive: true,
+        });
+    if (!reportFolder) {
+        throw new Error(`Could not create directory ${options.dir}`);
+    }
+    const actionStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'actions.jsonl'));
+    const dependenciesStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'dependencies.jsonl'));
+    const entrypointStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'entrypoints.jsonl'));
+    const startedAt = performance.now();
+    const timings = new Map();
+    const addTiming = (label, key, value) => {
+        if (!timings.has(label)) {
+            timings.set(label, new Map());
+        }
+        const forLabel = timings.get(label);
+        forLabel.set(key, Math.round((forLabel.get(key) || 0) + value));
+    };
+    const processDependencyEvent = ({ file, only, imports, fileIdx, }) => {
+        writeJSONl(dependenciesStream, {
+            file,
+            only,
+            imports,
+            fileIdx,
+        });
+    };
+    const processSingleEvent = (meta) => {
+        if (meta.type === 'dependency') {
+            processDependencyEvent(meta);
+        }
+    };
+    const startTimes = new Map();
+    const onEvent = (meta, type) => {
+        if (type === 'single') {
+            processSingleEvent(meta);
+            return;
+        }
+        if (type === 'start') {
+            Object.entries(meta).forEach(([label, value]) => {
+                startTimes.set(`${label}\0${value}`, performance.now());
+            });
+        }
+        else {
+            Object.entries(meta).forEach(([label, value]) => {
+                const startTime = startTimes.get(`${label}\0${value}`);
+                if (startTime) {
+                    addTiming(label, String(value), performance.now() - startTime);
+                }
+            });
+        }
+    };
+    let actionId = 0;
+    const onAction = (...args) => {
+        if ((0, EventEmitter_1.isOnActionStartArgs)(args)) {
+            const [, timestamp, type, idx, entrypointRef] = args;
+            writeJSONl(actionStream, {
+                actionId,
+                entrypointRef,
+                idx,
+                startedAt: timestamp,
+                type,
+            });
+            // eslint-disable-next-line no-plusplus
+            return actionId++;
+        }
+        const [result, timestamp, id, isAsync, error] = args;
+        writeJSONl(actionStream, {
+            actionId: id,
+            error,
+            finishedAt: timestamp,
+            isAsync,
+            result: `${result}ed`,
+        });
+        return id;
+    };
+    const onEntrypointEvent = (emitterId, timestamp, event) => {
+        entrypointStream.write(`${JSON.stringify([emitterId, timestamp, event])}\n`);
+    };
+    const emitter = new EventEmitter_1.EventEmitter(onEvent, onAction, onEntrypointEvent);
+    return {
+        emitter,
+        onDone: (sourceRoot) => {
+            if (options.print) {
+                printTimings(timings, startedAt, sourceRoot);
+                console.log('\nMemory usage:', process.memoryUsage());
+            }
+            actionStream.end();
+            dependenciesStream.end();
+            timings.clear();
+        },
+    };
+};
+exports.createFileReporter = createFileReporter;

package/types/evaluators/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is an entry point for module evaluation for getting lazy dependencies.
+ */
+import type { Entrypoint } from '../transform/Entrypoint';
+import type { Services } from '../transform/types';
+export interface IEvaluateResult {
+    dependencies: string[];
+    value: Record<string | symbol, unknown>;
+}
+export default function evaluate(services: Services, entrypoint: Entrypoint): IEvaluateResult;

package/types/evaluators/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * This file is an entry point for module evaluation for getting lazy dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const module_1 = require("../module");
+function evaluate(services, entrypoint) {
+    const m = new module_1.Module(services, entrypoint);
+    m.evaluate();
+    return {
+        value: entrypoint.exports,
+        dependencies: m.dependencies,
+    };
+}
+exports.default = evaluate;

package/types/index.d.ts

@@ -0,0 +1,30 @@
+export { slugify } from '@wyw-in-js/shared';
+export { createFileReporter } from './debug/fileReporter';
+export type { IFileReporterOptions } from './debug/fileReporter';
+export { default as preeval } from './plugins/preeval';
+export { getTransformMetadata, withTransformMetadata, } from './utils/TransformMetadata';
+export type { WYWTransformMetadata } from './utils/TransformMetadata';
+export { Module, DefaultModuleImplementation } from './module';
+export { transform } from './transform';
+export { isUnprocessedEntrypointError, UnprocessedEntrypointError, } from './transform/actions/UnprocessedEntrypointError';
+export * from './types';
+export { EvaluatedEntrypoint } from './transform/EvaluatedEntrypoint';
+export type { IEvaluatedEntrypoint } from './transform/EvaluatedEntrypoint';
+export { parseFile } from './transform/Entrypoint.helpers';
+export type { LoadAndParseFn } from './transform/Entrypoint.types';
+export { baseHandlers } from './transform/generators';
+export { prepareCode } from './transform/generators/transform';
+export { Entrypoint } from './transform/Entrypoint';
+export { transformUrl } from './transform/generators/extract';
+export { asyncResolveImports, syncResolveImports, } from './transform/generators/resolveImports';
+export { loadLinariaOptions } from './transform/helpers/loadLinariaOptions';
+export { withDefaultServices } from './transform/helpers/withDefaultServices';
+export type { Services } from './transform/types';
+export type { EventEmitter } from './utils/EventEmitter';
+export { isNode } from './utils/isNode';
+export { getTagProcessor } from './utils/getTagProcessor';
+export { getVisitorKeys } from './utils/getVisitorKeys';
+export type { VisitorKeys } from './utils/getVisitorKeys';
+export { peek } from './utils/peek';
+export { processTemplateExpression } from './utils/processTemplateExpression';
+export { TransformCacheCollection } from './cache';

package/types/index.js

@@ -0,0 +1,69 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformCacheCollection = exports.processTemplateExpression = exports.peek = exports.getVisitorKeys = exports.getTagProcessor = exports.isNode = exports.withDefaultServices = exports.loadLinariaOptions = exports.syncResolveImports = exports.asyncResolveImports = exports.transformUrl = exports.Entrypoint = exports.prepareCode = exports.baseHandlers = exports.parseFile = exports.EvaluatedEntrypoint = exports.UnprocessedEntrypointError = exports.isUnprocessedEntrypointError = exports.transform = exports.DefaultModuleImplementation = exports.Module = exports.withTransformMetadata = exports.getTransformMetadata = exports.preeval = exports.createFileReporter = exports.slugify = void 0;
+var shared_1 = require("@wyw-in-js/shared");
+Object.defineProperty(exports, "slugify", { enumerable: true, get: function () { return shared_1.slugify; } });
+var fileReporter_1 = require("./debug/fileReporter");
+Object.defineProperty(exports, "createFileReporter", { enumerable: true, get: function () { return fileReporter_1.createFileReporter; } });
+var preeval_1 = require("./plugins/preeval");
+Object.defineProperty(exports, "preeval", { enumerable: true, get: function () { return __importDefault(preeval_1).default; } });
+var TransformMetadata_1 = require("./utils/TransformMetadata");
+Object.defineProperty(exports, "getTransformMetadata", { enumerable: true, get: function () { return TransformMetadata_1.getTransformMetadata; } });
+Object.defineProperty(exports, "withTransformMetadata", { enumerable: true, get: function () { return TransformMetadata_1.withTransformMetadata; } });
+var module_1 = require("./module");
+Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return module_1.Module; } });
+Object.defineProperty(exports, "DefaultModuleImplementation", { enumerable: true, get: function () { return module_1.DefaultModuleImplementation; } });
+var transform_1 = require("./transform");
+Object.defineProperty(exports, "transform", { enumerable: true, get: function () { return transform_1.transform; } });
+var UnprocessedEntrypointError_1 = require("./transform/actions/UnprocessedEntrypointError");
+Object.defineProperty(exports, "isUnprocessedEntrypointError", { enumerable: true, get: function () { return UnprocessedEntrypointError_1.isUnprocessedEntrypointError; } });
+Object.defineProperty(exports, "UnprocessedEntrypointError", { enumerable: true, get: function () { return UnprocessedEntrypointError_1.UnprocessedEntrypointError; } });
+__exportStar(require("./types"), exports);
+var EvaluatedEntrypoint_1 = require("./transform/EvaluatedEntrypoint");
+Object.defineProperty(exports, "EvaluatedEntrypoint", { enumerable: true, get: function () { return EvaluatedEntrypoint_1.EvaluatedEntrypoint; } });
+var Entrypoint_helpers_1 = require("./transform/Entrypoint.helpers");
+Object.defineProperty(exports, "parseFile", { enumerable: true, get: function () { return Entrypoint_helpers_1.parseFile; } });
+var generators_1 = require("./transform/generators");
+Object.defineProperty(exports, "baseHandlers", { enumerable: true, get: function () { return generators_1.baseHandlers; } });
+var transform_2 = require("./transform/generators/transform");
+Object.defineProperty(exports, "prepareCode", { enumerable: true, get: function () { return transform_2.prepareCode; } });
+var Entrypoint_1 = require("./transform/Entrypoint");
+Object.defineProperty(exports, "Entrypoint", { enumerable: true, get: function () { return Entrypoint_1.Entrypoint; } });
+var extract_1 = require("./transform/generators/extract");
+Object.defineProperty(exports, "transformUrl", { enumerable: true, get: function () { return extract_1.transformUrl; } });
+var resolveImports_1 = require("./transform/generators/resolveImports");
+Object.defineProperty(exports, "asyncResolveImports", { enumerable: true, get: function () { return resolveImports_1.asyncResolveImports; } });
+Object.defineProperty(exports, "syncResolveImports", { enumerable: true, get: function () { return resolveImports_1.syncResolveImports; } });
+var loadLinariaOptions_1 = require("./transform/helpers/loadLinariaOptions");
+Object.defineProperty(exports, "loadLinariaOptions", { enumerable: true, get: function () { return loadLinariaOptions_1.loadLinariaOptions; } });
+var withDefaultServices_1 = require("./transform/helpers/withDefaultServices");
+Object.defineProperty(exports, "withDefaultServices", { enumerable: true, get: function () { return withDefaultServices_1.withDefaultServices; } });
+var isNode_1 = require("./utils/isNode");
+Object.defineProperty(exports, "isNode", { enumerable: true, get: function () { return isNode_1.isNode; } });
+var getTagProcessor_1 = require("./utils/getTagProcessor");
+Object.defineProperty(exports, "getTagProcessor", { enumerable: true, get: function () { return getTagProcessor_1.getTagProcessor; } });
+var getVisitorKeys_1 = require("./utils/getVisitorKeys");
+Object.defineProperty(exports, "getVisitorKeys", { enumerable: true, get: function () { return getVisitorKeys_1.getVisitorKeys; } });
+var peek_1 = require("./utils/peek");
+Object.defineProperty(exports, "peek", { enumerable: true, get: function () { return peek_1.peek; } });
+var processTemplateExpression_1 = require("./utils/processTemplateExpression");
+Object.defineProperty(exports, "processTemplateExpression", { enumerable: true, get: function () { return processTemplateExpression_1.processTemplateExpression; } });
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "TransformCacheCollection", { enumerable: true, get: function () { return cache_1.TransformCacheCollection; } });

package/types/module.d.ts

@@ -0,0 +1,62 @@
+/**
+ * This is a custom implementation for the module system for evaluating code,
+ * used for resolving values for dependencies interpolated in `css` or `styled`.
+ *
+ * This serves 2 purposes:
+ * - Avoid leakage from evaluated code to module cache in current context, e.g. `babel-register`
+ * - Allow us to invalidate the module cache without affecting other stuff, necessary for rebuilds
+ *
+ * We also use it to transpile the code with Babel by default.
+ * We also store source maps for it to provide correct error stacktraces.
+ *
+ */
+/// <reference types="node" />
+/// <reference types="debug" />
+import NativeModule from 'module';
+import type { Debugger } from '@wyw-in-js/shared';
+import './utils/dispose-polyfill';
+import { Entrypoint } from './transform/Entrypoint';
+import type { IEntrypointDependency } from './transform/Entrypoint.types';
+import type { IEvaluatedEntrypoint } from './transform/EvaluatedEntrypoint';
+import type { Services } from './transform/types';
+type HiddenModuleMembers = {
+    _extensions: Record<string, () => void>;
+    _resolveFilename: (id: string, options: {
+        filename: string;
+        id: string;
+        paths: string[];
+    }) => string;
+    _nodeModulePaths(filename: string): string[];
+};
+export declare const DefaultModuleImplementation: typeof NativeModule & HiddenModuleMembers;
+export declare class Module {
+    #private;
+    private services;
+    private moduleImpl;
+    readonly callstack: string[];
+    readonly debug: Debugger;
+    readonly dependencies: string[];
+    readonly extensions: string[];
+    readonly filename: string;
+    id: string;
+    readonly idx: string;
+    readonly ignored: boolean;
+    isEvaluated: boolean;
+    readonly parentIsIgnored: boolean;
+    require: {
+        (id: string): unknown;
+        ensure: () => void;
+        resolve: (id: string) => string;
+    };
+    resolve: (id: string) => string;
+    private cache;
+    constructor(services: Services, entrypoint: Entrypoint, parentModule?: Module, moduleImpl?: HiddenModuleMembers);
+    get exports(): Record<string | symbol, unknown>;
+    set exports(value: Record<string | symbol, unknown>);
+    protected get entrypoint(): Entrypoint;
+    evaluate(): void;
+    getEntrypoint(filename: string, only: string[], log: Debugger): Entrypoint | IEvaluatedEntrypoint | null;
+    resolveDependency: (id: string) => IEntrypointDependency;
+    protected createChild(entrypoint: Entrypoint): Module;
+}
+export {};

package/types/module.js

@@ -0,0 +1,318 @@
+"use strict";
+/**
+ * This is a custom implementation for the module system for evaluating code,
+ * used for resolving values for dependencies interpolated in `css` or `styled`.
+ *
+ * This serves 2 purposes:
+ * - Avoid leakage from evaluated code to module cache in current context, e.g. `babel-register`
+ * - Allow us to invalidate the module cache without affecting other stuff, necessary for rebuilds
+ *
+ * We also use it to transpile the code with Babel by default.
+ * We also store source maps for it to provide correct error stacktraces.
+ *
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = exports.DefaultModuleImplementation = void 0;
+const fs_1 = __importDefault(require("fs"));
+const module_1 = __importDefault(require("module"));
+const path_1 = __importDefault(require("path"));
+const vm_1 = __importDefault(require("vm"));
+const ts_invariant_1 = require("ts-invariant");
+require("./utils/dispose-polyfill");
+const Entrypoint_1 = require("./transform/Entrypoint");
+const Entrypoint_helpers_1 = require("./transform/Entrypoint.helpers");
+const UnprocessedEntrypointError_1 = require("./transform/actions/UnprocessedEntrypointError");
+const createVmContext_1 = require("./vm/createVmContext");
+exports.DefaultModuleImplementation = module_1.default;
+// Supported node builtins based on the modules polyfilled by webpack
+// `true` means module is polyfilled, `false` means module is empty
+const builtins = {
+    assert: true,
+    buffer: true,
+    child_process: false,
+    cluster: false,
+    console: true,
+    constants: true,
+    crypto: true,
+    dgram: false,
+    dns: false,
+    domain: true,
+    events: true,
+    fs: false,
+    http: true,
+    https: true,
+    module: false,
+    net: false,
+    os: true,
+    path: true,
+    punycode: true,
+    process: true,
+    querystring: true,
+    readline: false,
+    repl: false,
+    stream: true,
+    string_decoder: true,
+    sys: true,
+    timers: true,
+    tls: false,
+    tty: true,
+    url: true,
+    util: true,
+    vm: true,
+    zlib: true,
+};
+const NOOP = () => { };
+function getUncached(cached, test) {
+    const cachedSet = new Set(typeof cached === 'string' ? cached.split(',') : cached);
+    if (cachedSet.has('*')) {
+        return [];
+    }
+    return test.filter((t) => !cachedSet.has(t));
+}
+function resolve(id) {
+    const { resolved } = this.resolveDependency(id);
+    (0, ts_invariant_1.invariant)(resolved, `Unable to resolve "${id}"`);
+    return resolved;
+}
+class Module {
+    services;
+    moduleImpl;
+    callstack = [];
+    debug;
+    dependencies;
+    extensions;
+    filename;
+    id;
+    idx;
+    ignored;
+    isEvaluated = false;
+    parentIsIgnored;
+    require = Object.assign((id) => {
+        if (id in builtins) {
+            // The module is in the allowed list of builtin node modules
+            // Ideally we should prevent importing them, but webpack polyfills some
+            // So we check for the list of polyfills to determine which ones to support
+            if (builtins[id]) {
+                this.debug('require', `builtin '${id}'`);
+                return require(id);
+            }
+            return null;
+        }
+        // Resolve module id (and filename) relatively to parent module
+        const dependency = this.resolveDependency(id);
+        if (dependency.resolved === id && !path_1.default.isAbsolute(id)) {
+            // The module is a builtin node modules, but not in the allowed list
+            throw new Error(`Unable to import "${id}". Importing Node builtins is not supported in the sandbox.`);
+        }
+        (0, ts_invariant_1.invariant)(dependency.resolved, `Dependency ${dependency.source} cannot be resolved`);
+        this.dependencies.push(id);
+        this.debug('require', `${id} -> ${dependency.resolved}`);
+        const entrypoint = this.getEntrypoint(dependency.resolved, dependency.only, this.debug);
+        if (entrypoint === null) {
+            return dependency.resolved;
+        }
+        if (entrypoint.evaluated ||
+            (0, Entrypoint_helpers_1.isSuperSet)(entrypoint.evaluatedOnly, dependency.only)) {
+            return entrypoint.exports;
+        }
+        const m = this.createChild(entrypoint);
+        m.evaluate();
+        return entrypoint.exports;
+    }, {
+        ensure: NOOP,
+        resolve: resolve.bind(this),
+    });
+    resolve = resolve.bind(this);
+    cache;
+    #entrypointRef;
+    constructor(services, entrypoint, parentModule, moduleImpl = exports.DefaultModuleImplementation) {
+        this.services = services;
+        this.moduleImpl = moduleImpl;
+        this.cache = services.cache;
+        this.#entrypointRef = new WeakRef(entrypoint);
+        this.idx = entrypoint.idx;
+        this.id = entrypoint.name;
+        this.filename = entrypoint.name;
+        this.dependencies = [];
+        this.debug = entrypoint.log.extend('module');
+        this.parentIsIgnored = parentModule?.ignored ?? false;
+        this.ignored = entrypoint.ignored ?? this.parentIsIgnored;
+        if (parentModule) {
+            this.callstack = [entrypoint.name, ...parentModule.callstack];
+        }
+        else {
+            this.callstack = [entrypoint.name];
+        }
+        this.extensions = services.options.pluginOptions.extensions;
+        this.debug('init', entrypoint.name);
+    }
+    get exports() {
+        return this.entrypoint.exports;
+    }
+    set exports(value) {
+        this.entrypoint.exports = value;
+        this.debug('the whole exports was overridden with %O', value);
+    }
+    get entrypoint() {
+        const entrypoint = this.#entrypointRef.deref();
+        (0, ts_invariant_1.invariant)(entrypoint, `Module ${this.idx} is disposed`);
+        return entrypoint;
+    }
+    evaluate() {
+        const { entrypoint } = this;
+        entrypoint.assertTransformed();
+        const cached = this.cache.get('entrypoints', entrypoint.name);
+        let evaluatedCreated = false;
+        if (!entrypoint.supersededWith) {
+            this.cache.add('entrypoints', entrypoint.name, entrypoint.createEvaluated());
+            evaluatedCreated = true;
+        }
+        const { transformedCode: source } = entrypoint;
+        const { pluginOptions } = this.services.options;
+        if (!source) {
+            this.debug(`evaluate`, 'there is nothing to evaluate');
+            return;
+        }
+        if (this.isEvaluated) {
+            this.debug('evaluate', `is already evaluated`);
+            return;
+        }
+        this.debug('evaluate');
+        this.debug.extend('source')('%s', source);
+        this.isEvaluated = true;
+        const { filename } = this;
+        if (/\.json$/.test(filename)) {
+            // For JSON files, parse it to a JS object similar to Node
+            this.exports = JSON.parse(source);
+            return;
+        }
+        const { context, teardown } = (0, createVmContext_1.createVmContext)(filename, pluginOptions.features, {
+            module: this,
+            exports: entrypoint.exports,
+            require: this.require,
+            __wyw_dynamic_import: async (id) => this.require(id),
+            __dirname: path_1.default.dirname(filename),
+        }, pluginOptions.overrideContext);
+        try {
+            const script = new vm_1.default.Script(`(function (exports) { ${source}\n})(exports);`, {
+                filename,
+            });
+            script.runInContext(context);
+        }
+        catch (e) {
+            this.isEvaluated = false;
+            if (evaluatedCreated) {
+                this.cache.add('entrypoints', entrypoint.name, cached);
+            }
+            if ((0, UnprocessedEntrypointError_1.isUnprocessedEntrypointError)(e)) {
+                // It will be handled by evalFile scenario
+                throw e;
+            }
+            if (e instanceof EvalError) {
+                this.debug('%O', e);
+                throw e;
+            }
+            this.debug('%O\n%O', e, this.callstack);
+            throw new EvalError(`${e.message} in${this.callstack.join('\n| ')}\n`);
+        }
+        finally {
+            teardown();
+        }
+    }
+    getEntrypoint(filename, only, log) {
+        const extension = path_1.default.extname(filename);
+        if (extension !== '.json' && !this.extensions.includes(extension)) {
+            return null;
+        }
+        const entrypoint = this.cache.get('entrypoints', filename);
+        if (entrypoint && (0, Entrypoint_helpers_1.isSuperSet)(entrypoint.evaluatedOnly ?? [], only)) {
+            log('✅ file has been already evaluated');
+            return entrypoint;
+        }
+        if (entrypoint?.ignored) {
+            log('✅ file has been ignored during prepare stage. Original code will be used');
+            return entrypoint;
+        }
+        if (this.ignored) {
+            log('✅ one of the parent files has been ignored during prepare stage. Original code will be used');
+            const newEntrypoint = this.entrypoint.createChild(filename, ['*'], fs_1.default.readFileSync(filename, 'utf-8'));
+            if (newEntrypoint === 'loop') {
+                const stack = (0, Entrypoint_helpers_1.getStack)(this.entrypoint);
+                throw new Error(`Circular dependency detected: ${stack.join(' -> ')} -> ${filename}`);
+            }
+            return newEntrypoint;
+        }
+        // Requested file can be already prepared for evaluation on the stage 1
+        if (only && entrypoint) {
+            const uncachedExports = getUncached(entrypoint.only ?? [], only);
+            if (uncachedExports.length === 0) {
+                log('✅ ready for evaluation');
+                return entrypoint;
+            }
+            log('❌ file has been processed during prepare stage but %o is not evaluated yet (evaluated: %o)', uncachedExports, entrypoint.only);
+        }
+        else {
+            log('❌ file has not been processed during prepare stage');
+        }
+        // If code wasn't extracted from cache, it indicates that we were unable
+        // to process some of the imports on stage1. Let's try to reprocess.
+        const code = fs_1.default.readFileSync(filename, 'utf-8');
+        const newEntrypoint = Entrypoint_1.Entrypoint.createRoot(this.services, filename, only, code);
+        if (newEntrypoint.evaluated) {
+            log('✅ file has been already evaluated');
+            return newEntrypoint;
+        }
+        if (newEntrypoint.ignored) {
+            log('✅ file has been ignored during prepare stage. Original code will be used');
+            return newEntrypoint;
+        }
+        return newEntrypoint;
+    }
+    resolveDependency = (id) => {
+        const cached = this.entrypoint.getDependency(id);
+        (0, ts_invariant_1.invariant)(!(cached instanceof Promise), 'Dependency is not resolved yet');
+        if (cached) {
+            return cached;
+        }
+        if (!this.ignored) {
+            this.debug('❌ import has not been resolved during prepare stage. Fallback to Node.js resolver');
+        }
+        const extensions = this.moduleImpl._extensions;
+        const added = [];
+        try {
+            // Check for supported extensions
+            this.extensions.forEach((ext) => {
+                if (ext in extensions) {
+                    return;
+                }
+                // When an extension is not supported, add it
+                // And keep track of it to clean it up after resolving
+                // Use noop for the transform function since we handle it
+                extensions[ext] = NOOP;
+                added.push(ext);
+            });
+            const { filename } = this;
+            const resolved = this.moduleImpl._resolveFilename(id, {
+                id: filename,
+                filename,
+                paths: this.moduleImpl._nodeModulePaths(path_1.default.dirname(filename)),
+            });
+            return {
+                source: id,
+                only: ['*'],
+                resolved,
+            };
+        }
+        finally {
+            // Cleanup the extensions we added to restore previous behaviour
+            added.forEach((ext) => delete extensions[ext]);
+        }
+    };
+    createChild(entrypoint) {
+        return new Module(this.services, entrypoint, this, this.moduleImpl);
+    }
+}
+exports.Module = Module;

package/types/options/buildOptions.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="src/options/babel-merge" />
+import type { TransformOptions } from '@babel/core';
+/**
+ * Merges babel configs together. If a pair of configs were merged before,
+ * it will return the cached result.
+ */
+export declare function buildOptions(...configs: (TransformOptions | null | undefined)[]): TransformOptions;