@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.1

package/types/shaker.d.ts

@@ -1,12 +1,4 @@
-import type { TransformOptions } from '@babel/core';
-import type { File } from '@babel/types';
-import type { Evaluator, EvaluatorConfig } from '@wyw-in-js/shared';
-type ShakerStageResult = [
-    ast: File,
-    code: string,
-    imports: Map<string, string[]> | null
-];
-export declare const shakeToESM: (evalConfig: TransformOptions, ast: File, code: string, config: EvaluatorConfig, babel: Parameters<Evaluator>[4]) => ShakerStageResult;
-export declare const emitCommonJS: (evalConfig: TransformOptions, ast: File, code: string, babel: Parameters<Evaluator>[4]) => [ast: File, code: string];
+import type { Evaluator } from '@wyw-in-js/shared';
+export declare const oxcShaker: Evaluator;
 export declare const shaker: Evaluator;
 export default shaker;

package/types/shaker.js

@@ -1,100 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shaker = exports.emitCommonJS = exports.shakeToESM = void 0;
-const shaker_1 = __importDefault(require("./plugins/shaker"));
-const ShakerMetadata_1 = require("./utils/ShakerMetadata");
-const getPluginKey_1 = require("./utils/getPluginKey");
-const hasKeyInList = (plugin, list) => {
-    const pluginKey = (0, getPluginKey_1.getPluginKey)(plugin);
-    return pluginKey ? list.some((i) => pluginKey.includes(i)) : false;
-};
-const isCommonJSPlugin = (plugin) => (0, getPluginKey_1.getPluginKey)(plugin) === 'transform-modules-commonjs';
-const safeResolve = (id, paths) => {
-    try {
-        return require.resolve(id, {
-            paths: paths.filter((i) => i !== null),
-        });
-    }
-    catch {
-        return null;
-    }
-};
-const ensureTypescriptPlugin = (plugins, evalConfig) => {
-    if (!evalConfig.filename?.endsWith('.ts') &&
-        !evalConfig.filename?.endsWith('.tsx') &&
-        !evalConfig.filename?.endsWith('.mts') &&
-        !evalConfig.filename?.endsWith('.cts')) {
-        return;
-    }
-    const hasTypescriptPlugin = plugins.some((i) => (0, getPluginKey_1.getPluginKey)(i) === 'transform-typescript');
-    if (hasTypescriptPlugin) {
-        return;
-    }
-    const preset = safeResolve('@babel/preset-typescript', [evalConfig.filename]);
-    const plugin = safeResolve('@babel/plugin-transform-typescript', [
-        evalConfig.filename,
-        preset,
-    ]);
-    if (plugin) {
-        plugins.push([plugin, { allowDeclareFields: true }]);
-    }
-};
-const createShakerPlugins = (evalConfig, config, includeCommonJS) => {
-    const { highPriorityPlugins, ...shakerConfig } = config;
-    const preShakePlugins = evalConfig.plugins?.filter((i) => hasKeyInList(i, highPriorityPlugins)) ??
-        [];
-    const plugins = [
-        ...preShakePlugins,
-        [shaker_1.default, shakerConfig],
-        ...(evalConfig.plugins ?? []).filter((i) => !hasKeyInList(i, highPriorityPlugins) && !isCommonJSPlugin(i)),
-    ];
-    ensureTypescriptPlugin(plugins, evalConfig);
-    if (includeCommonJS) {
-        plugins.push(require.resolve('@babel/plugin-transform-modules-commonjs'));
-    }
-    return plugins;
-};
-const shakeToESM = (evalConfig, ast, code, config, babel) => {
-    const transformed = babel.transformFromAstSync(ast, code, {
-        ...evalConfig,
-        ast: true,
-        caller: {
-            name: 'wyw-in-js',
-        },
-        plugins: createShakerPlugins(evalConfig, config, false),
-    });
-    if (!transformed || !(0, ShakerMetadata_1.hasShakerMetadata)(transformed.metadata)) {
-        throw new Error(`${evalConfig.filename} has no shaker metadata`);
-    }
-    return [
-        transformed.ast,
-        transformed.code ?? '',
-        transformed.metadata.wywEvaluator.imports,
-    ];
-};
-exports.shakeToESM = shakeToESM;
-const emitCommonJS = (evalConfig, ast, code, babel) => {
-    const transformed = babel.transformFromAstSync(ast, code, {
-        ...evalConfig,
-        ast: true,
-        caller: {
-            name: 'wyw-in-js',
-        },
-        plugins: [require.resolve('@babel/plugin-transform-modules-commonjs')],
-    });
-    if (!transformed?.ast) {
-        throw new Error('Babel transform failed');
-    }
-    return [transformed.ast, transformed.code ?? ''];
-};
-exports.emitCommonJS = emitCommonJS;
-const shaker = (evalConfig, ast, code, config, babel) => {
-    const [esmAst, esmCode, imports] = (0, exports.shakeToESM)(evalConfig, ast, code, config, babel);
-    const [, commonJSCode] = (0, exports.emitCommonJS)(evalConfig, esmAst, esmCode, babel);
-    return [esmAst, commonJSCode, imports];
-};
-exports.shaker = shaker;
-exports.default = exports.shaker;
+import { emitOxcCommonJS } from './utils/oxcEmit';
+import { shakeOxcToESM } from './utils/oxcShaker';
+export const oxcShaker = (evalConfig, ast, code, config) => {
+    const filename = evalConfig.filename ?? 'unknown.js';
+    const shaken = shakeOxcToESM(code, filename, config);
+    const emitted = emitOxcCommonJS(shaken.code, filename);
+    return [ast, emitted.code, shaken.imports];
+};
+export const shaker = oxcShaker;
+export default shaker;

package/types/transform/BaseEntrypoint.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntrypoint = exports.createExports = void 0;
-const getFileIdx_1 = require("../utils/getFileIdx");
+import { getFileIdx } from '../utils/getFileIdx';
 const hasKey = (obj, key) => (typeof obj === 'object' || typeof obj === 'function') &&
     obj !== null &&
     key in obj;
 const VALUES = Symbol('values');
 const isProxy = (obj) => typeof obj === 'object' && obj !== null && VALUES in obj;
-const createExports = (log) => {
+export const createExports = (log) => {
     let exports = {};
     const lazyFields = new Set();
     return new Proxy(exports, {
@@ -105,10 +102,9 @@ const createExports = (log) => {
         },
     });
 };
-exports.createExports = createExports;
 const EXPORTS = Symbol('exports');
 let entrypointSeqId = 0;
-class BaseEntrypoint {
+export class BaseEntrypoint {
     services;
     evaluatedOnly;
     generation;
@@ -118,7 +114,7 @@ class BaseEntrypoint {
     dependencies;
     invalidationDependencies;
     invalidateOnDependencyChange;
-    static createExports = exports.createExports;
+    static createExports = createExports;
     idx;
     log;
     // eslint-disable-next-line no-plusplus
@@ -134,7 +130,7 @@ class BaseEntrypoint {
         this.dependencies = dependencies;
         this.invalidationDependencies = invalidationDependencies;
         this.invalidateOnDependencyChange = invalidateOnDependencyChange;
-        this.idx = (0, getFileIdx_1.getFileIdx)(name);
+        this.idx = getFileIdx(name);
         this.log =
             parents[0]?.log.extend(this.ref, '->') ?? services.log.extend(this.ref);
         this.dependencies = dependencies;
@@ -145,7 +141,7 @@ class BaseEntrypoint {
                 isExportsInherited = true;
             }
             else {
-                this.#exports = (0, exports.createExports)(this.log);
+                this.#exports = createExports(this.log);
                 this.#exports[EXPORTS] = exports;
             }
             this.exports = exports;
@@ -186,4 +182,3 @@ class BaseEntrypoint {
         return this.#exports;
     }
 }
-exports.BaseEntrypoint = BaseEntrypoint;

package/types/transform/Entrypoint.d.ts

@@ -1,10 +1,13 @@
 import type { ParentEntrypoint, ITransformFileResult } from '../types';
 import { BaseEntrypoint } from './BaseEntrypoint';
-import type { IEntrypointCode, IEntrypointDependency, IIgnoredEntrypoint } from './Entrypoint.types';
+import type { IEntrypointCode, IEntrypointDependency, IIgnoredEntrypoint, IPreevalResult } from './Entrypoint.types';
 import { EvaluatedEntrypoint } from './EvaluatedEntrypoint';
 import type { ActionByType } from './actions/BaseAction';
 import { BaseAction } from './actions/BaseAction';
 import type { Services, ActionTypes } from './types';
+type CreateEntrypointOptions = {
+    mergeCachedOnly?: boolean;
+};
 export declare class Entrypoint extends BaseEntrypoint {
     #private;
     readonly initialCode: string | undefined;
@@ -12,29 +15,21 @@ export declare class Entrypoint extends BaseEntrypoint {
     readonly dependencies: Map<string, IEntrypointDependency>;
     readonly invalidationDependencies: Map<string, IEntrypointDependency>;
     readonly invalidateOnDependencyChange: Set<string>;
+    private readonly skipCacheInvalidation;
     readonly evaluated = false;
     readonly loadedAndParsed: IEntrypointCode | IIgnoredEntrypoint;
     protected onSupersedeHandlers: Array<(newEntrypoint: Entrypoint) => void>;
     private actionsCache;
+    private static readonly RESOLVE_TASK_MAX_NULL_ATTEMPTS;
     private constructor();
     get ignored(): boolean;
     get originalCode(): string | undefined;
     get supersededWith(): Entrypoint | null;
     get transformedCode(): string | null;
-    static createRoot(services: Services, name: string, only: string[], loadedCode: string | undefined): Entrypoint;
-    /**
-     * Creates an entrypoint for the specified file.
-     * If there is already an entrypoint for this file, there will be four possible outcomes:
-     * 1. If `loadedCode` is specified and is different from the one that was used to create the existing entrypoint,
-     *   the existing entrypoint will be superseded by a new one and all cached results for it will be invalidated.
-     *   It can happen if the file was changed and the watcher notified us about it, or we received a new version
-     *   of the file from a loader whereas the previous one was loaded from the filesystem.
-     *   The new entrypoint will be returned.
-     * 2. If `only` is subset of the existing entrypoint's `only`, the existing entrypoint will be returned.
-     * 3. If `only` is superset of the existing entrypoint's `only`, the existing entrypoint will be superseded and the new one will be returned.
-     * 4. If a loop is detected, 'ignored' will be returned, the existing entrypoint will be superseded or not depending on the `only` value.
-     */
-    protected static create(services: Services, parent: ParentEntrypoint | null, name: string, only: string[], loadedCode: string | undefined): Entrypoint | 'loop';
+    get transformed(): boolean;
+    get isProcessing(): boolean;
+    static createRoot(services: Services, name: string, only: string[], loadedCode: string | undefined, options?: CreateEntrypointOptions): Entrypoint;
+    protected static create(services: Services, parent: ParentEntrypoint | null, name: string, only: string[], loadedCode: string | undefined, options?: CreateEntrypointOptions): Entrypoint | 'loop';
     private static innerCreate;
     addDependency(dependency: IEntrypointDependency): void;
     addInvalidationDependency(dependency: IEntrypointDependency): void;
@@ -48,12 +43,17 @@ export declare class Entrypoint extends BaseEntrypoint {
     createEvaluated(): EvaluatedEntrypoint;
     endProcessing(): void;
     getDependency(name: string): IEntrypointDependency | undefined;
+    getPreevalResult(): IPreevalResult | null;
     getInvalidationDependency(name: string): IEntrypointDependency | undefined;
     markInvalidateOnDependencyChange(filename: string): void;
     getResolveTask(name: string): Promise<IEntrypointDependency> | undefined;
     hasWywMetadata(): boolean;
+    waitForProcessing(): Promise<void>;
+    reuseTransformResult(code: string | null, hasWywMetadata: boolean): void;
     onSupersede(callback: (newEntrypoint: Entrypoint) => void): () => void;
     setTransformResult(res: ITransformFileResult | null): void;
+    setPreevalResult(result: IPreevalResult): void;
     private deferOnlySupersede;
     private supersede;
 }
+export {};

package/types/transform/Entrypoint.helpers.d.ts

@@ -1,12 +1,9 @@
-import type { TransformOptions } from '@babel/core';
-import type { File } from '@babel/types';
 import type { Debugger, EvalRule } from '@wyw-in-js/shared';
-import type { Core } from '../babel';
 import type { ParentEntrypoint } from '../types';
-import type { IEntrypointCode, IIgnoredEntrypoint } from './Entrypoint.types';
+import type { IEntrypointCode, IIgnoredEntrypoint, ParsedAst } from './Entrypoint.types';
 import type { Services } from './types';
 export declare function getMatchedRule(rules: EvalRule[], filename: string, code: string): EvalRule;
-export declare function parseFile(babel: Core, filename: string, originalCode: string, parseConfig: TransformOptions): File;
+export declare function parseFile(_runtime: unknown, filename: string, originalCode: string): ParsedAst;
 export declare function loadAndParse(services: Services, name: string, loadedCode: string | undefined, log: Debugger): IEntrypointCode | IIgnoredEntrypoint;
 export declare function getStack(entrypoint: ParentEntrypoint): string[];
 export declare function mergeOnly(a: string[], b: string[]): string[];

package/types/transform/Entrypoint.helpers.js

@@ -1,20 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSuperSet = void 0;
-exports.getMatchedRule = getMatchedRule;
-exports.parseFile = parseFile;
-exports.loadAndParse = loadAndParse;
-exports.getStack = getStack;
-exports.mergeOnly = mergeOnly;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const shared_1 = require("@wyw-in-js/shared");
-const buildOptions_1 = require("../options/buildOptions");
-const loadBabelOptions_1 = require("../options/loadBabelOptions");
-const getFileIdx_1 = require("../utils/getFileIdx");
-const getPluginKey_1 = require("../utils/getPluginKey");
-const parseRequest_1 = require("../utils/parseRequest");
-function getMatchedRule(rules, filename, code) {
+import { readFileSync } from 'fs';
+import { dirname, extname, isAbsolute } from 'path';
+import { createRequire } from 'module';
+import { parseSync } from 'oxc-parser';
+import { logger } from '@wyw-in-js/shared';
+import { oxcShaker } from '../shaker';
+import { getFileIdx } from '../utils/getFileIdx';
+import { stripQueryAndHash } from '../utils/parseRequest';
+const nodeRequire = createRequire(import.meta.url);
+export function getMatchedRule(rules, filename, code) {
     for (let i = rules.length - 1; i >= 0; i--) {
         const rule = rules[i];
         if (!rule.test) {
@@ -29,177 +22,28 @@ function getMatchedRule(rules, filename, code) {
     }
     return { action: 'ignore' };
 }
-function parseFile(babel, filename, originalCode, parseConfig) {
-    const log = shared_1.logger.extend('transform:parse').extend((0, getFileIdx_1.getFileIdx)(filename));
-    const parseResult = babel.parseSync(originalCode, parseConfig);
-    if (!parseResult) {
-        throw new Error(`Failed to parse ${filename}`);
-    }
-    log('stage-1', `${filename} has been parsed`);
-    return parseResult;
-}
-const isModuleResolver = (plugin) => {
-    const key = (0, getPluginKey_1.getPluginKey)(plugin);
-    if (!key)
-        return false;
-    if (['module-resolver', 'babel-plugin-module-resolver'].includes(key)) {
-        return true;
-    }
-    return /([\\/])babel-plugin-module-resolver\1/.test(key);
-};
-let moduleResolverWarned = false;
-const normalizeBabelKey = (key) => key.replace(/\\/g, '/');
-const isBabelPresetTypescript = (key) => {
-    const normalized = normalizeBabelKey(key);
-    if (normalized === 'typescript')
-        return true;
-    return normalized.includes('preset-typescript');
-};
-const isBabelTransformTypescriptPlugin = (key) => {
-    const normalized = normalizeBabelKey(key);
-    if (normalized === 'transform-typescript')
-        return true;
-    return normalized.includes('plugin-transform-typescript');
-};
-const withAllowDeclareFields = (item) => {
-    if (!Array.isArray(item)) {
-        return [item, { allowDeclareFields: true }];
-    }
-    const [target, rawOptions, ...rest] = item;
-    const options = typeof rawOptions === 'object' &&
-        rawOptions !== null &&
-        !Array.isArray(rawOptions)
-        ? rawOptions
-        : {};
-    if ('allowDeclareFields' in options) {
-        return item;
-    }
-    return [target, { ...options, allowDeclareFields: true }, ...rest];
-};
-const ensureAllowDeclareFieldsInBabelOptions = (babelOptions, scope = 'top') => {
-    let presetsChanged = false;
-    let pluginsChanged = false;
-    let overridesChanged = false;
-    let envChanged = false;
-    const presets = babelOptions.presets?.map((item) => {
-        const key = (0, getPluginKey_1.getPluginKey)(item);
-        if (!key || !isBabelPresetTypescript(key)) {
-            return item;
-        }
-        presetsChanged = true;
-        return withAllowDeclareFields(item);
-    });
-    const plugins = babelOptions.plugins?.map((item) => {
-        const key = (0, getPluginKey_1.getPluginKey)(item);
-        if (!key || !isBabelTransformTypescriptPlugin(key)) {
-            return item;
-        }
-        pluginsChanged = true;
-        return withAllowDeclareFields(item);
-    });
-    const { overrides: baseOverrides } = babelOptions;
-    let overrides = baseOverrides;
-    if (scope === 'top' && baseOverrides) {
-        const patchedOverrides = baseOverrides.map((override) => ensureAllowDeclareFieldsInBabelOptions(override, 'override'));
-        if (patchedOverrides.some((patchedOverride, idx) => patchedOverride !== baseOverrides[idx])) {
-            overridesChanged = true;
-            overrides = patchedOverrides;
-        }
-    }
-    const { env: baseEnv } = babelOptions;
-    let env = baseEnv;
-    if (scope === 'top' && baseEnv) {
-        const entries = Object.entries(baseEnv);
-        const patchedEntries = entries.map(([envName, envOptions]) => [
-            envName,
-            envOptions
-                ? ensureAllowDeclareFieldsInBabelOptions(envOptions, 'env')
-                : envOptions,
-        ]);
-        if (patchedEntries.some(([, patched], idx) => patched !== entries[idx][1])) {
-            envChanged = true;
-            env = Object.fromEntries(patchedEntries);
-        }
-    }
-    if (!presetsChanged && !pluginsChanged && !overridesChanged && !envChanged) {
-        return babelOptions;
-    }
-    const next = { ...babelOptions };
-    if (presetsChanged)
-        next.presets = presets;
-    if (pluginsChanged)
-        next.plugins = plugins;
-    if (overridesChanged)
-        next.overrides = overrides;
-    if (envChanged)
-        next.env = env;
-    return next;
-};
-function buildConfigs(services, name, pluginOptions, babelOptions) {
-    const { babel, options } = services;
-    const commonOptions = {
-        ast: true,
-        filename: name,
-        inputSourceMap: options.inputSourceMap,
-        root: options.root,
-        sourceFileName: name,
-        sourceMaps: true,
-    };
-    const isTypescriptFile = name.endsWith('.ts') ||
-        name.endsWith('.tsx') ||
-        name.endsWith('.mts') ||
-        name.endsWith('.cts');
-    let rawConfig = (0, buildOptions_1.buildOptions)(pluginOptions?.babelOptions, babelOptions, commonOptions);
-    if (isTypescriptFile) {
-        rawConfig = ensureAllowDeclareFieldsInBabelOptions(rawConfig);
-    }
-    const useBabelConfigs = (0, shared_1.isFeatureEnabled)(pluginOptions.features, 'useBabelConfigs', name);
-    if (!useBabelConfigs) {
-        rawConfig = {
-            ...rawConfig,
-            configFile: false,
-        };
-    }
-    const parseConfig = (0, loadBabelOptions_1.loadBabelOptions)(babel, name, {
-        babelrc: useBabelConfigs,
-        ...rawConfig,
+export function parseFile(_runtime, filename, originalCode) {
+    const log = logger.extend('transform:parse').extend(getFileIdx(filename));
+    const parseResult = parseSync(filename, originalCode, {
+        astType: filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js',
+        range: true,
+        sourceType: 'module',
     });
-    const parseHasModuleResolver = parseConfig.plugins?.some(isModuleResolver);
-    const rawHasModuleResolver = rawConfig.plugins?.some(isModuleResolver);
-    if (parseHasModuleResolver && !rawHasModuleResolver) {
-        if (!moduleResolverWarned) {
-            // eslint-disable-next-line no-console
-            console.warn(`[wyw-in-js] ${name} has a module-resolver plugin in its babelrc, but it is not present ` +
-                `in the babelOptions for the wyw-in-js plugin. This works for now but will be an error in the future. ` +
-                `Please add the module-resolver plugin to the babelOptions for the wyw-in-js plugin.`);
-            moduleResolverWarned = true;
-        }
-        rawConfig = {
-            ...rawConfig,
-            plugins: [
-                ...(parseConfig.plugins?.filter((plugin) => isModuleResolver(plugin)) ??
-                    []),
-                ...(rawConfig.plugins ?? []),
-            ],
-        };
+    const fatalError = parseResult.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
     }
-    const evalConfig = (0, loadBabelOptions_1.loadBabelOptions)(babel, name, {
-        babelrc: false,
-        ...rawConfig,
-    });
-    return {
-        evalConfig,
-        parseConfig,
-    };
+    log('stage-1', `${filename} has been parsed`);
+    return parseResult.program;
 }
-function loadAndParse(services, name, loadedCode, log) {
-    const { babel, eventEmitter, options: { pluginOptions }, } = services;
-    const filename = (0, parseRequest_1.stripQueryAndHash)(name);
-    const extension = (0, path_1.extname)(filename);
+export function loadAndParse(services, name, loadedCode, log) {
+    const { options: { pluginOptions }, } = services;
+    const filename = stripQueryAndHash(name);
+    const extension = extname(filename);
     if (!pluginOptions.extensions.includes(extension)) {
         log('[createEntrypoint] %s is ignored. If you want it to be processed, you should add \'%s\' to the "extensions" option.', filename, extension);
         return {
-            code: (0, path_1.isAbsolute)(filename) ? loadedCode : '',
+            code: isAbsolute(filename) ? loadedCode : '',
             evaluator: 'ignored',
             reason: 'extension',
         };
@@ -213,22 +57,11 @@ function loadAndParse(services, name, loadedCode, log) {
             code = cachedEntrypoint.initialCode;
         }
     }
-    code ??= (0, fs_1.readFileSync)(filename, 'utf-8');
-    const { action, babelOptions } = getMatchedRule(pluginOptions.rules, filename, code);
-    let ast;
-    const { evalConfig, parseConfig } = buildConfigs(services, filename, pluginOptions, babelOptions);
-    const getOrParse = () => {
-        if (ast)
-            return ast;
-        ast = eventEmitter.perf('parseFile', () => parseFile(babel, name, code, parseConfig));
-        return ast;
-    };
+    code ??= readFileSync(filename, 'utf-8');
+    const { action } = getMatchedRule(pluginOptions.rules, filename, code);
     if (action === 'ignore') {
         log('[createEntrypoint] %s is ignored by rule', name);
         return {
-            get ast() {
-                return getOrParse();
-            },
             code,
             evaluator: 'ignored',
             reason: 'rule',
@@ -236,19 +69,27 @@ function loadAndParse(services, name, loadedCode, log) {
     }
     const evaluator = typeof action === 'function'
         ? action
-        : require(require.resolve(action, {
-            paths: [(0, path_1.dirname)(filename)],
+        : nodeRequire(nodeRequire.resolve(action, {
+            paths: [dirname(filename)],
         })).default;
+    if (evaluator !== oxcShaker) {
+        throw new Error(`[wyw-in-js] ${filename} matched a legacy evaluator. The Oxc runtime path supports only the default Oxc evaluator.`);
+    }
     return {
         get ast() {
-            return getOrParse();
+            return null;
         },
         code,
         evaluator,
-        evalConfig,
+        evalConfig: {
+            ast: false,
+            configFile: false,
+            filename,
+            root: services.options.root ?? process.cwd(),
+        },
     };
 }
-function getStack(entrypoint) {
+export function getStack(entrypoint) {
     if (!entrypoint)
         return [];
     const stack = [entrypoint.name];
@@ -259,12 +100,12 @@ function getStack(entrypoint) {
     }
     return stack;
 }
-function mergeOnly(a, b) {
+export function mergeOnly(a, b) {
     const result = new Set(a);
     b.forEach((item) => result.add(item));
     return [...result].filter((i) => i).sort();
 }
-const isSuperSet = (a, b) => {
+export const isSuperSet = (a, b) => {
     if (a.includes('*'))
         return true;
     if (b.length === 0)
@@ -272,4 +113,3 @@ const isSuperSet = (a, b) => {
     const aSet = new Set(a);
     return b.every((item) => aSet.has(item));
 };
-exports.isSuperSet = isSuperSet;