@bleedingdev/modern-js-code-tools 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/cjs/module-graph.cjs

@@ -0,0 +1,1862 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createModuleGraph: ()=>createModuleGraph,
+    exportedConst: ()=>exportedConst,
+    localConst: ()=>localConst,
+    propertyName: ()=>propertyName
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const types_namespaceObject = require("@babel/types");
+const external_resolve_exports_namespaceObject = require("resolve.exports");
+const external_source_analysis_cjs_namespaceObject = require("./source-analysis.cjs");
+const MAX_LOOKUPS = 4096;
+const MAX_DEPTH = 192;
+const MAX_ALIASES = 512;
+const staticKey = (node)=>{
+    const key = 'property' in node ? node.property : node.key;
+    return !node.computed || types_namespaceObject.isStringLiteral(key) || types_namespaceObject.isNumericLiteral(key) ? propertyName(key) : void 0;
+};
+const writeTarget = (node)=>{
+    let names = [];
+    let dynamic = false;
+    let depth = 0;
+    let current = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(node, true);
+    while(types_namespaceObject.isMemberExpression(current) || types_namespaceObject.isOptionalMemberExpression(current)){
+        const name = staticKey(current);
+        depth += 1;
+        if (void 0 === name) {
+            names = [];
+            dynamic = true;
+        } else names.unshift(name);
+        current = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(current.object, true);
+    }
+    return types_namespaceObject.isIdentifier(current) ? {
+        root: current,
+        path: names,
+        dynamic,
+        depth
+    } : void 0;
+};
+const OPAQUE_RECEIVER = {};
+const opaqueReceiver = (target, scope)=>{
+    let current = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(target, true);
+    if (!types_namespaceObject.isMemberExpression(current) && !types_namespaceObject.isOptionalMemberExpression(current)) return false;
+    let depth = 0;
+    while(types_namespaceObject.isMemberExpression(current) || types_namespaceObject.isOptionalMemberExpression(current)){
+        depth += 1;
+        current = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(current.object, true);
+    }
+    if (types_namespaceObject.isThisExpression(current)) {
+        if (depth > 1) return true;
+        let owner = scope.getFunctionParent();
+        while(owner && types_namespaceObject.isArrowFunctionExpression(owner.block))owner = owner.parent?.getFunctionParent() ?? null;
+        return !(types_namespaceObject.isClassMethod(owner?.block) && 'constructor' === owner.block.kind);
+    }
+    return !(types_namespaceObject.isIdentifier(current) || types_namespaceObject.isSuper(current));
+};
+const CONTAINER_EXTRACTORS = new Set([
+    'at',
+    'concat',
+    'copyWithin',
+    'entries',
+    'every',
+    'fill',
+    'filter',
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'flat',
+    'flatMap',
+    'forEach',
+    'get',
+    'map',
+    'pop',
+    'reduce',
+    'reduceRight',
+    'reverse',
+    'shift',
+    'slice',
+    'some',
+    'sort',
+    'splice',
+    'toReversed',
+    'toSorted',
+    'toSpliced',
+    'values',
+    'with'
+]);
+const RECEIVER_RETURNING_METHODS = new Set([
+    'copyWithin',
+    'fill',
+    'reverse',
+    'sort',
+    'valueOf'
+]);
+const isModuleExports = (node)=>types_namespaceObject.isMemberExpression(node) && types_namespaceObject.isIdentifier(node.object, {
+        name: 'module'
+    }) && 'exports' === staticKey(node);
+const readsModuleExports = (node)=>{
+    let current = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(node, true);
+    for(let hop = 0; hop < MAX_DEPTH; hop += 1){
+        if (isModuleExports(current)) return true;
+        if (!types_namespaceObject.isAssignmentExpression(current, {
+            operator: '='
+        })) break;
+        if (isModuleExports(current.left)) return true;
+        current = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(current.right, true);
+    }
+    return false;
+};
+const READ_ONLY_GLOBAL_CALLS = new Set([
+    'Object.assign',
+    'Object.defineProperties',
+    'Object.defineProperty',
+    'Object.setPrototypeOf',
+    'Reflect.defineProperty',
+    'Reflect.deleteProperty',
+    'Reflect.set',
+    'Reflect.setPrototypeOf',
+    'Array.isArray',
+    'Boolean',
+    'JSON.stringify',
+    'Number',
+    'Object.is',
+    'Object.isExtensible',
+    'Object.isFrozen',
+    'Object.isSealed',
+    'Object.keys',
+    'String'
+]);
+const STORING_GLOBAL_CALLS = new Map([
+    [
+        'Object.assign',
+        (depth)=>Math.max(depth, 1)
+    ],
+    [
+        'Object.setPrototypeOf',
+        (depth)=>Math.max(depth, 1)
+    ],
+    [
+        'Reflect.setPrototypeOf',
+        (depth)=>Math.max(depth, 1)
+    ],
+    [
+        'Object.defineProperty',
+        (depth)=>Math.max(depth, 1)
+    ],
+    [
+        'Reflect.defineProperty',
+        (depth)=>Math.max(depth, 1)
+    ],
+    [
+        'Object.defineProperties',
+        ()=>1
+    ],
+    [
+        'Reflect.set',
+        (depth)=>depth + 1
+    ]
+]);
+const DYNAMIC_SETTER = Symbol('dynamic setter');
+const setterCache = new WeakMap();
+const setterNames = (program)=>{
+    const cached = setterCache.get(program.node);
+    if (cached) return cached;
+    const names = new Set();
+    types_namespaceObject.traverseFast(program.node, (node)=>{
+        if ((types_namespaceObject.isObjectMethod(node) || types_namespaceObject.isClassMethod(node)) && 'set' === node.kind) names.add(staticKey(node) ?? DYNAMIC_SETTER);
+    });
+    setterCache.set(program.node, names);
+    return names;
+};
+const patternMembers = (pattern, from = [])=>types_namespaceObject.isMemberExpression(pattern) || types_namespaceObject.isOptionalMemberExpression(pattern) ? [
+        {
+            target: pattern,
+            from
+        }
+    ] : types_namespaceObject.isObjectPattern(pattern) ? pattern.properties.flatMap((property)=>{
+        if (types_namespaceObject.isRestElement(property)) return patternMembers(property.argument, void 0);
+        const key = staticKey(property);
+        return patternMembers(property.value, from && void 0 !== key ? [
+            ...from,
+            key
+        ] : void 0);
+    }) : types_namespaceObject.isArrayPattern(pattern) ? pattern.elements.flatMap((element, index)=>element ? patternMembers(element, from && !types_namespaceObject.isRestElement(element) ? [
+            ...from,
+            String(index)
+        ] : void 0) : []) : types_namespaceObject.isRestElement(pattern) ? patternMembers(pattern.argument, void 0) : types_namespaceObject.isAssignmentPattern(pattern) ? patternMembers(pattern.left, void 0) : [];
+function parseModule(filePath, workspace) {
+    if (external_node_fs_default().statSync(filePath).size > 1000000) throw new Error(`${filePath}: consumer source exceeds 1 MB analysis budget`);
+    const file = (0, external_source_analysis_cjs_namespaceObject.parseSource)(external_node_fs_default().readFileSync(filePath, 'utf8'), filePath);
+    let scope;
+    const references = new Map();
+    const declarations = new Map();
+    const returns = new Map();
+    const bareReturns = new Set();
+    const functionScopes = new Map();
+    const writes = new Map();
+    const merged = new Set();
+    const mutations = [];
+    const commonJs = [];
+    let exportsDetachedAt;
+    const assertAssignable = (binding, at)=>{
+        if (binding?.kind === 'const' || binding?.kind === 'module') throw new external_source_analysis_cjs_namespaceObject.SourceSyntaxError(`${'module' === binding.kind ? 'imports' : 'const bindings'} must not be reassigned at ${at.start}`);
+    };
+    const recordWrite = (scopeOf, target, node, value, from)=>{
+        const member = writeTarget(target);
+        if (!member) {
+            if (opaqueReceiver(target, scopeOf)) writes.set(OPAQUE_RECEIVER, [
+                ...writes.get(OPAQUE_RECEIVER) ?? [],
+                {
+                    path: [],
+                    dynamic: true,
+                    depth: 0,
+                    value,
+                    from,
+                    node
+                }
+            ]);
+            return;
+        }
+        let root = member;
+        let through = [];
+        for(let hop = 0; hop < MAX_DEPTH; hop += 1){
+            const alias = scopeOf.getBinding(root.root.name);
+            const init = alias?.kind === 'const' && types_namespaceObject.isVariableDeclarator(alias.path.node) ? alias.path.node.init : void 0;
+            const next = init ? writeTarget(init) : void 0;
+            if (!next || next.dynamic) break;
+            through = [
+                ...root.path,
+                ...through
+            ];
+            root = next;
+        }
+        const exported = 'module' === root.root.name && 'exports' === root.path[0] ? [
+            ...root.path.slice(1),
+            ...through
+        ] : 'exports' === root.root.name ? [
+            ...root.path,
+            ...through
+        ] : void 0;
+        const detached = 'exports' === root.root.name && (root.path.length + through.length === 0 || void 0 !== exportsDetachedAt && (node.start ?? 0) >= exportsDetachedAt);
+        if (exported && !detached && !scopeOf.getBinding(root.root.name)) commonJs.push({
+            path: exported,
+            dynamic: member.dynamic,
+            depth: member.depth,
+            value,
+            from,
+            node
+        });
+        const binding = member.dynamic || member.path.length > 0 ? scopeOf.getBinding(member.root.name) : void 0;
+        if (!binding) return;
+        writes.set(binding, [
+            ...writes.get(binding) ?? [],
+            {
+                path: member.path,
+                dynamic: member.dynamic,
+                depth: member.depth,
+                value,
+                from,
+                node
+            }
+        ]);
+    };
+    const indexBuiltInMutation = (p)=>{
+        const callee = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(p.node.callee, true);
+        const memberCallee = types_namespaceObject.isMemberExpression(callee) || types_namespaceObject.isOptionalMemberExpression(callee) ? callee : void 0;
+        const owner = memberCallee && types_namespaceObject.isIdentifier(memberCallee.object) ? memberCallee.object.name : void 0;
+        const method = memberCallee ? staticKey(memberCallee) : void 0;
+        const [target, ...rest] = p.node.arguments;
+        if (!owner || !method || !target || !types_namespaceObject.isExpression(target) || p.scope.getBinding(owner) || !('Object' === owner && [
+            'assign',
+            'defineProperty',
+            'defineProperties',
+            'setPrototypeOf'
+        ].includes(method) || 'Reflect' === owner && [
+            'set',
+            'defineProperty',
+            'deleteProperty',
+            'setPrototypeOf'
+        ].includes(method))) return;
+        mutations.push(p.node);
+        const anyMember = types_namespaceObject.memberExpression(target, types_namespaceObject.identifier('key'), true);
+        const sources = 'assign' === method ? rest : [
+            void 0
+        ];
+        for (const source of sources){
+            if (!types_namespaceObject.isObjectExpression(source)) {
+                recordWrite(p.scope, anyMember, p.node);
+                continue;
+            }
+            for (const property of source.properties){
+                const key = types_namespaceObject.isObjectProperty(property) ? staticKey(property) : void 0;
+                void 0 !== key && types_namespaceObject.isObjectProperty(property) ? recordWrite(p.scope, types_namespaceObject.memberExpression(target, types_namespaceObject.stringLiteral(key), true), p.node, property.value) : recordWrite(p.scope, anyMember, p.node);
+            }
+        }
+    };
+    (0, external_source_analysis_cjs_namespaceObject.traverseSource)(file, {
+        Program (p) {
+            scope = p.scope;
+        },
+        ReferencedIdentifier (p) {
+            references.set(p.node, p.scope.getBinding(p.node.name));
+        },
+        BindingIdentifier (p) {
+            if (!types_namespaceObject.isIdentifier(p.node)) return;
+            const binding = p.scope.getBinding(p.node.name);
+            if (binding?.identifier === p.node) declarations.set(p.node, binding);
+        },
+        Function (p) {
+            functionScopes.set(p.node, p.scope);
+        },
+        ReturnStatement (p) {
+            const owner = p.getFunctionParent();
+            if (!owner) return;
+            if (p.node.argument) returns.set(owner.node, [
+                ...returns.get(owner.node) ?? [],
+                p.node.argument
+            ]);
+            else bareReturns.add(owner.node);
+        },
+        AssignmentExpression (p) {
+            mutations.push(p.node);
+            const stored = [
+                '=',
+                '&&=',
+                '||=',
+                '??='
+            ].includes(p.node.operator) ? p.node.right : void 0;
+            for (const name of Object.keys(types_namespaceObject.getBindingIdentifiers(p.node.left)))assertAssignable(p.scope.getBinding(name), p.node);
+            if (types_namespaceObject.isPattern(p.node.left)) for (const { target, from } of patternMembers(p.node.left))recordWrite(p.scope, target, p.node, from && '=' === p.node.operator ? p.node.right : void 0, from);
+            else recordWrite(p.scope, p.node.left, p.node, stored);
+            if ('=' === p.node.operator && types_namespaceObject.isIdentifier(p.node.left, {
+                name: 'exports'
+            }) && !p.scope.getBinding('exports') && p.parentPath.isExpressionStatement() && p.parentPath.parentPath?.isProgram()) exportsDetachedAt = readsModuleExports(p.node.right) ? void 0 : exportsDetachedAt ?? p.node.end ?? void 0;
+            else if (void 0 === exportsDetachedAt && '=' === p.node.operator && types_namespaceObject.isMemberExpression(p.node.left) && types_namespaceObject.isIdentifier(p.node.left.object, {
+                name: 'module'
+            }) && 'exports' === staticKey(p.node.left) && !p.scope.getBinding('module') && !(types_namespaceObject.isAssignmentExpression(p.node.right) && types_namespaceObject.isIdentifier(p.node.right.left, {
+                name: 'exports'
+            })) && p.parentPath.isExpressionStatement() && p.parentPath.parentPath?.isProgram()) exportsDetachedAt = p.node.end ?? void 0;
+        },
+        ForXStatement (p) {
+            const left = p.node.left;
+            if (types_namespaceObject.isVariableDeclaration(left)) return;
+            mutations.push(p.node);
+            for (const { target } of patternMembers(left))recordWrite(p.scope, target, p.node);
+        },
+        CallExpression (p) {
+            indexBuiltInMutation(p);
+        },
+        OptionalCallExpression (p) {
+            indexBuiltInMutation(p);
+        },
+        UnaryExpression (p) {
+            if ('delete' !== p.node.operator) return;
+            mutations.push(p.node);
+            recordWrite(p.scope, p.node.argument, p.node);
+        },
+        UpdateExpression (p) {
+            mutations.push(p.node);
+            if (types_namespaceObject.isIdentifier(p.node.argument)) assertAssignable(p.scope.getBinding(p.node.argument.name), p.node);
+            recordWrite(p.scope, p.node.argument, p.node);
+        },
+        TSModuleDeclaration (p) {
+            if (!types_namespaceObject.isIdentifier(p.node.id)) return;
+            merged.add(p.node.id.name);
+            mutations.push(p.node);
+        }
+    });
+    if (!scope) throw new Error(`${filePath}: program scope missing`);
+    const facts = {
+        scope,
+        workspace,
+        references,
+        declarations,
+        returns,
+        bareReturns,
+        functionScopes,
+        writes,
+        merged,
+        commonJs
+    };
+    return {
+        file,
+        facts,
+        mutations
+    };
+}
+const propertyName = (node)=>{
+    if (void 0 !== node && (types_namespaceObject.isIdentifier(node) || types_namespaceObject.isStringLiteral(node) || types_namespaceObject.isNumericLiteral(node))) return types_namespaceObject.isIdentifier(node) ? node.name : String(node.value);
+};
+const localConst = (sourceFile, name)=>{
+    for (const item of sourceFile.program.body){
+        const statement = types_namespaceObject.isExportNamedDeclaration(item) ? item.declaration : item;
+        if (!types_namespaceObject.isVariableDeclaration(statement) || 'const' !== statement.kind) continue;
+        const matches = statement.declarations.filter((declaration)=>types_namespaceObject.isIdentifier(declaration.id, {
+                name
+            }));
+        if (1 === matches.length) return matches[0];
+    }
+};
+const exportedConst = (sourceFile, name)=>{
+    for (const statement of sourceFile.program.body)if (types_namespaceObject.isExportNamedDeclaration(statement) && 'type' !== statement.exportKind) {
+        if (types_namespaceObject.isVariableDeclaration(statement.declaration) && 'const' === statement.declaration.kind) {
+            const declaration = statement.declaration.declarations.find((value)=>types_namespaceObject.isIdentifier(value.id, {
+                    name
+                }));
+            if (declaration) return declaration;
+        }
+        if (!statement.source && statement.specifiers.some((value)=>types_namespaceObject.isExportSpecifier(value) && 'type' !== value.exportKind && types_namespaceObject.isIdentifier(value.local, {
+                name
+            }) && types_namespaceObject.isIdentifier(value.exported, {
+                name
+            }))) return localConst(sourceFile, name);
+    }
+};
+const inside = (file, boundary)=>file === boundary || file.startsWith(`${boundary}${external_node_path_default().sep}`);
+const containingWorkspace = (file)=>{
+    for(let directory = external_node_path_default().dirname(file);; directory = external_node_path_default().dirname(directory)){
+        if (external_node_fs_default().existsSync(external_node_path_default().join(directory, 'pnpm-workspace.yaml'))) return external_node_fs_default().realpathSync(directory);
+        if (directory === external_node_path_default().dirname(directory)) return;
+    }
+};
+const sourceBoundary = (file, workspace)=>{
+    for(let directory = external_node_path_default().dirname(file);; directory = external_node_path_default().dirname(directory)){
+        if (external_node_fs_default().existsSync(external_node_path_default().join(directory, 'package.json')) && directory !== workspace) return external_node_fs_default().realpathSync(directory);
+        if (directory === workspace || directory === external_node_path_default().dirname(directory)) return external_node_fs_default().realpathSync(external_node_path_default().dirname(file));
+    }
+};
+const sourceFileAt = (target, boundary)=>{
+    const stem = target.replace(/\.(?:[cm]?[jt]sx?)$/u, '');
+    for (const candidate of [
+        `${stem}.ts`,
+        `${stem}.tsx`,
+        `${stem}.mts`,
+        `${stem}.cts`,
+        target,
+        `${stem}.js`,
+        `${stem}.jsx`,
+        `${stem}.mjs`,
+        `${stem}.cjs`,
+        external_node_path_default().join(target, 'index.ts'),
+        external_node_path_default().join(target, 'index.tsx'),
+        external_node_path_default().join(target, 'index.mts'),
+        external_node_path_default().join(target, 'index.cts'),
+        external_node_path_default().join(target, 'index.js'),
+        external_node_path_default().join(target, 'index.jsx'),
+        external_node_path_default().join(target, 'index.mjs'),
+        external_node_path_default().join(target, 'index.cjs')
+    ])try {
+        const real = external_node_fs_default().realpathSync(candidate);
+        if (inside(real, boundary) && external_node_fs_default().statSync(real).isFile()) return real;
+    } catch  {}
+};
+const packageEntry = (specifier)=>{
+    if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('#')) return;
+    const parts = specifier.split('/');
+    const count = specifier.startsWith('@') ? 2 : 1;
+    if (parts.length < count || parts.slice(0, count).some((part)=>!part)) return;
+    return {
+        name: parts.slice(0, count).join('/'),
+        exportKey: parts.length === count ? '.' : `./${parts.slice(count).join('/')}`
+    };
+};
+const resolveModulePath = (module, specifier, workspace)=>{
+    if (/^\.\.?\//u.test(specifier)) {
+        const file = sourceFileAt(external_node_path_default().resolve(external_node_path_default().dirname(module.path), specifier), module.boundary);
+        return void 0 === file ? void 0 : {
+            kind: 'module',
+            path: file,
+            boundary: module.boundary
+        };
+    }
+    const entry = packageEntry(specifier);
+    if (!entry) return;
+    if (!workspace) return {
+        kind: 'external'
+    };
+    const paths = (0, external_node_module_namespaceObject.createRequire)(module.path).resolve.paths(entry.name) ?? [];
+    for (const lookup of paths){
+        const directory = external_node_path_default().join(lookup, entry.name);
+        const manifest = external_node_path_default().join(directory, 'package.json');
+        if (!external_node_fs_default().existsSync(manifest)) continue;
+        const boundary = external_node_fs_default().realpathSync(directory);
+        if (!inside(boundary, workspace) || boundary.split(external_node_path_default().sep).includes('node_modules')) break;
+        const pkg = JSON.parse(external_node_fs_default().readFileSync(manifest, 'utf8'));
+        if (pkg.name !== entry.name || void 0 === pkg.exports) return;
+        let target;
+        try {
+            const targets = (0, external_resolve_exports_namespaceObject.exports)({
+                ...pkg,
+                exports: selectExportPattern(pkg.exports, entry.exportKey)
+            }, entry.exportKey, {
+                conditions: [
+                    'modern:source'
+                ]
+            });
+            target = Array.isArray(targets) ? targets[0] : void 0;
+        } catch  {
+            return;
+        }
+        if (!target || !target.startsWith('./')) return;
+        const file = sourceFileAt(external_node_path_default().resolve(boundary, target), boundary);
+        return void 0 === file ? void 0 : {
+            kind: 'module',
+            path: file,
+            boundary
+        };
+    }
+    return {
+        kind: 'external'
+    };
+};
+const patternKeyCompare = (a, b)=>{
+    const aBase = a.indexOf('*') + 1;
+    const bBase = b.indexOf('*') + 1;
+    if (aBase !== bBase) return bBase - aBase;
+    return b.length - a.length;
+};
+const selectExportPattern = (exports1, key)=>{
+    if ('object' != typeof exports1 || null === exports1 || Array.isArray(exports1)) return exports1;
+    const subpaths = exports1;
+    const keys = Object.keys(subpaths);
+    if (!keys.every((candidate)=>candidate.startsWith('.')) || key in subpaths) return exports1;
+    let best;
+    for (const candidate of keys){
+        const star = candidate.indexOf('*');
+        if (-1 === star || -1 !== candidate.indexOf('*', star + 1)) continue;
+        const prefix = candidate.slice(0, star);
+        const suffix = candidate.slice(star + 1);
+        if (key.startsWith(prefix) && key !== prefix && key.endsWith(suffix) && key.length >= candidate.length && (void 0 === best || patternKeyCompare(candidate, best) < 0)) best = candidate;
+    }
+    return void 0 === best ? exports1 : {
+        [best]: subpaths[best]
+    };
+};
+const exportHop = (file, name)=>{
+    for (const statement of file.program.body){
+        if (types_namespaceObject.isExportDefaultDeclaration(statement)) {
+            if ('default' !== name) continue;
+            const declaration = statement.declaration;
+            if (types_namespaceObject.isIdentifier(declaration)) return {
+                kind: 'local',
+                name: declaration.name
+            };
+            if ((types_namespaceObject.isFunctionDeclaration(declaration) || types_namespaceObject.isClassDeclaration(declaration)) && declaration.id) return {
+                kind: 'local',
+                name: declaration.id.name
+            };
+            return {
+                kind: 'node',
+                node: declaration
+            };
+        }
+        if (!types_namespaceObject.isExportNamedDeclaration(statement) || 'type' === statement.exportKind) continue;
+        const declaration = statement.declaration;
+        if ((types_namespaceObject.isVariableDeclaration(declaration) || types_namespaceObject.isFunctionDeclaration(declaration) || types_namespaceObject.isClassDeclaration(declaration)) && !declaration.declare && name in types_namespaceObject.getBindingIdentifiers(declaration)) return {
+            kind: 'local',
+            name
+        };
+        for (const specifier of statement.specifiers){
+            if (propertyName(specifier.exported) !== name) continue;
+            if (types_namespaceObject.isExportNamespaceSpecifier(specifier) && statement.source) return {
+                kind: 'namespace',
+                specifier: statement.source.value
+            };
+            if (!types_namespaceObject.isExportSpecifier(specifier) || 'type' === specifier.exportKind) continue;
+            const local = propertyName(specifier.local) ?? name;
+            return statement.source ? {
+                kind: 'reexport',
+                specifier: statement.source.value,
+                name: local
+            } : {
+                kind: 'local',
+                name: local
+            };
+        }
+    }
+};
+const exportNames = (file)=>file.program.body.flatMap((statement)=>{
+        if (types_namespaceObject.isExportDefaultDeclaration(statement)) return [
+            'default'
+        ];
+        if (!types_namespaceObject.isExportNamedDeclaration(statement) || 'type' === statement.exportKind) return [];
+        const declared = !statement.declaration || types_namespaceObject.isTSTypeAliasDeclaration(statement.declaration) || types_namespaceObject.isTSInterfaceDeclaration(statement.declaration) ? [] : Object.keys(types_namespaceObject.getBindingIdentifiers(statement.declaration));
+        return [
+            ...declared,
+            ...statement.specifiers.flatMap((specifier)=>types_namespaceObject.isExportSpecifier(specifier) && 'type' === specifier.exportKind ? [] : [
+                    propertyName(specifier.exported) ?? ''
+                ])
+        ].filter(Boolean);
+    });
+const starSources = (file, name)=>'default' === name ? [] : file.program.body.flatMap((statement)=>types_namespaceObject.isExportAllDeclaration(statement) && 'type' !== statement.exportKind ? [
+            statement.source.value
+        ] : []);
+const importOf = (binding)=>{
+    const specifier = binding.path.node;
+    const declaration = binding.path.parent;
+    if (!types_namespaceObject.isImportDeclaration(declaration) || 'type' === declaration.importKind || 'typeof' === declaration.importKind || types_namespaceObject.isImportSpecifier(specifier) && 'type' === specifier.importKind) return;
+    const name = types_namespaceObject.isImportSpecifier(specifier) ? propertyName(specifier.imported) : types_namespaceObject.isImportDefaultSpecifier(specifier) ? 'default' : types_namespaceObject.isImportNamespaceSpecifier(specifier) ? '*' : void 0;
+    return void 0 === name ? void 0 : {
+        specifier: declaration.source.value,
+        name
+    };
+};
+const patternPath = (pattern, target)=>{
+    if (pattern === target) return {
+        members: [],
+        defaults: []
+    };
+    if (types_namespaceObject.isAssignmentPattern(pattern)) {
+        const inner = patternPath(pattern.left, target);
+        return void 0 === inner || 'dynamic' === inner ? inner : {
+            members: inner.members,
+            defaults: [
+                {
+                    members: [],
+                    value: pattern.right
+                },
+                ...inner.defaults
+            ]
+        };
+    }
+    if (types_namespaceObject.isObjectPattern(pattern)) for (const property of pattern.properties){
+        const inner = patternPath(types_namespaceObject.isRestElement(property) ? property.argument : property.value, target);
+        if (void 0 === inner) continue;
+        const key = types_namespaceObject.isObjectProperty(property) ? staticKey(property) : void 0;
+        if ('dynamic' === inner || void 0 === key) return 'dynamic';
+        return {
+            members: [
+                key,
+                ...inner.members
+            ],
+            defaults: inner.defaults.map((entry)=>({
+                    members: [
+                        key,
+                        ...entry.members
+                    ],
+                    value: entry.value
+                }))
+        };
+    }
+    if (types_namespaceObject.isArrayPattern(pattern)) for (const [index, element] of pattern.elements.entries()){
+        const inner = element ? patternPath(element, target) : void 0;
+        if (void 0 !== inner) {
+            if ('dynamic' === inner || types_namespaceObject.isRestElement(element)) return 'dynamic';
+            return {
+                members: [
+                    String(index),
+                    ...inner.members
+                ],
+                defaults: inner.defaults.map((entry)=>({
+                        members: [
+                            String(index),
+                            ...entry.members
+                        ],
+                        value: entry.value
+                    }))
+            };
+        }
+    }
+    if (types_namespaceObject.isRestElement(pattern)) return Object.values(types_namespaceObject.getBindingIdentifiers(pattern)).includes(target) ? 'dynamic' : void 0;
+};
+const objectRestPath = (pattern, target)=>{
+    if (!types_namespaceObject.isObjectPattern(pattern)) return;
+    const excluded = new Set();
+    for (const property of pattern.properties){
+        if (types_namespaceObject.isRestElement(property)) {
+            if (property.argument === target) return {
+                members: [],
+                excluded
+            };
+            continue;
+        }
+        const key = staticKey(property);
+        if (void 0 === key) break;
+        excluded.add(key);
+        const inner = objectRestPath(types_namespaceObject.isAssignmentPattern(property.value) ? property.value.left : property.value, target);
+        if (inner) return {
+            members: [
+                key,
+                ...inner.members
+            ],
+            excluded: inner.excluded
+        };
+    }
+};
+const callSitesOf = (fn)=>{
+    const outer = fn.parentPath;
+    if (types_namespaceObject.isCallExpression(outer?.node) && outer.node.callee === fn.node) return {
+        calls: [
+            outer
+        ],
+        escaped: false
+    };
+    const member = types_namespaceObject.isObjectMethod(fn.node) ? fn : types_namespaceObject.isObjectProperty(outer?.node) && outer.node.value === fn.node ? outer : void 0;
+    const key = member && types_namespaceObject.isObjectMember(member.node) ? staticKey(member.node) : void 0;
+    const getter = types_namespaceObject.isObjectMethod(fn.node) && 'get' === fn.node.kind;
+    const object = void 0 === key ? void 0 : member.parentPath;
+    const runAt = (callee)=>{
+        if (getter) return callee;
+        let invoked = callee;
+        const via = invoked.parentPath;
+        if (via && types_namespaceObject.isMemberExpression(via.node) && via.node.object === invoked.node && [
+            'call',
+            'apply'
+        ].includes(staticKey(via.node) ?? '')) invoked = via;
+        const call = invoked.parentPath;
+        return call && types_namespaceObject.isCallExpression(call.node) && call.node.callee === invoked.node ? call : void 0;
+    };
+    const calls = [];
+    let escaped = false;
+    const inline = object?.parentPath;
+    if (object && (types_namespaceObject.isMemberExpression(inline?.node) || types_namespaceObject.isOptionalMemberExpression(inline?.node)) && inline.node.object === object.node) {
+        const run = staticKey(inline.node) === key ? runAt(inline) : void 0;
+        return run ? {
+            calls: [
+                run
+            ],
+            escaped: false
+        } : {
+            calls,
+            escaped: true
+        };
+    }
+    const owner = object?.parentPath;
+    const name = types_namespaceObject.isFunctionDeclaration(fn.node) ? fn.node.id?.name : types_namespaceObject.isVariableDeclarator(outer?.node) && types_namespaceObject.isIdentifier(outer.node.id) ? outer.node.id.name : types_namespaceObject.isVariableDeclarator(owner?.node) && types_namespaceObject.isIdentifier(owner.node.id) ? owner.node.id.name : void 0;
+    const first = name ? (void 0 === key ? fn.scope.parent : owner.scope)?.getBinding(name) : void 0;
+    if (!first) return {
+        calls,
+        escaped: true
+    };
+    const bindings = [
+        first
+    ];
+    for(let index = 0; index < bindings.length && index < MAX_ALIASES; index += 1)for (let reference of bindings[index].referencePaths){
+        while(reference.parentPath && (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(reference.parent, true) !== reference.parent)reference = reference.parentPath;
+        const parent = reference.parent;
+        if (types_namespaceObject.isVariableDeclarator(parent) && parent.init === reference.node && types_namespaceObject.isIdentifier(parent.id)) {
+            const alias = reference.scope.getBinding(parent.id.name);
+            if (alias && !bindings.includes(alias)) bindings.push(alias);
+            continue;
+        }
+        const callee = void 0 === key ? reference : (types_namespaceObject.isMemberExpression(parent) || types_namespaceObject.isOptionalMemberExpression(parent)) && parent.object === reference.node && staticKey(parent) === key ? reference.parentPath : void 0;
+        const run = callee ? runAt(callee) : void 0;
+        if (run) calls.push(run);
+        else if (callee && (void 0 !== key || !isReadOnlyUse(reference))) escaped = true;
+        else if (!callee && !isReadOnlyUse(reference)) escaped = true;
+    }
+    return {
+        calls,
+        escaped
+    };
+};
+const methodOf = (literal, key, depth = 0)=>{
+    for (const entry of literal.get('properties').toReversed()){
+        if (entry.isObjectMethod() || entry.isObjectProperty()) {
+            let name = staticKey(entry.node);
+            if (void 0 === name) {
+                const folded = entry.get('key').evaluate();
+                if (!folded.confident || 'string' != typeof folded.value) return 'unknown';
+                name = folded.value;
+            }
+            if (name === key) return entry;
+        }
+        if (!entry.isSpreadElement()) continue;
+        const argument = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(entry.node.argument, true);
+        const binding = types_namespaceObject.isIdentifier(argument) ? entry.scope.getBinding(argument.name) : void 0;
+        const init = binding?.kind === 'const' && binding.path.isVariableDeclarator() ? binding.path.get('init') : void 0;
+        if (!init?.isObjectExpression() || depth >= MAX_DEPTH) return 'unknown';
+        const found = methodOf(init, key, depth + 1);
+        if (void 0 !== found) return found;
+    }
+};
+const functionOf = (binding)=>{
+    for(let hop = 0; binding && hop < MAX_DEPTH; hop += 1){
+        const declared = binding.path;
+        if (declared.isFunctionDeclaration()) return declared;
+        if (!declared.isVariableDeclarator() || 'const' !== binding.kind) break;
+        const init = declared.get('init');
+        let value = init;
+        while((0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(value.node, true) !== value.node)value = value.get('expression');
+        if (value.isFunction()) return value;
+        if (!value.isIdentifier()) break;
+        binding = value.scope.getBinding(value.node.name);
+    }
+};
+const isReadOnlyUse = (reference)=>{
+    const parent = reference.parent;
+    const node = reference.node;
+    return !types_namespaceObject.isExpression(node) || types_namespaceObject.isExportSpecifier(parent) || types_namespaceObject.isExportDefaultDeclaration(parent) || types_namespaceObject.isCallExpression(parent) && parent.callee === node || (types_namespaceObject.isMemberExpression(parent) || types_namespaceObject.isOptionalMemberExpression(parent)) && parent.object === node || types_namespaceObject.isExpressionStatement(parent) || types_namespaceObject.isUnaryExpression(parent) || types_namespaceObject.isBinaryExpression(parent) || types_namespaceObject.isTemplateLiteral(parent) || types_namespaceObject.isAssignmentExpression(parent) && parent.left === node || types_namespaceObject.isUpdateExpression(parent) && parent.argument === node || (types_namespaceObject.isIfStatement(parent) || types_namespaceObject.isConditionalExpression(parent) || types_namespaceObject.isWhileStatement(parent) || types_namespaceObject.isDoWhileStatement(parent) || types_namespaceObject.isForStatement(parent)) && 'test' in parent && parent.test === node || types_namespaceObject.isSwitchStatement(parent) && parent.discriminant === node;
+};
+const aliasCache = new WeakMap();
+const aliasesOf = (binding, writes)=>{
+    if (0 === writes.size) return [
+        {
+            binding,
+            prefix: []
+        }
+    ];
+    if (writes.has(OPAQUE_RECEIVER)) return;
+    if (aliasCache.has(binding)) return aliasCache.get(binding);
+    const result = collectAliases(binding, writes);
+    aliasCache.set(binding, result);
+    return result;
+};
+const collectAliases = (binding, writes)=>{
+    const found = [
+        {
+            binding,
+            prefix: [],
+            dynamic: false,
+            depth: 0
+        }
+    ];
+    let escaped = false;
+    const add = (entry)=>{
+        if (!found.some((known)=>known.binding === entry.binding && known.dynamic === entry.dynamic && known.depth === entry.depth && JSON.stringify(known.prefix) === JSON.stringify(entry.prefix))) found.push(entry);
+    };
+    for(let index = 0; index < found.length && index < MAX_ALIASES; index += 1)for (const start of found[index].binding.referencePaths){
+        const origin = found[index];
+        const pending = [
+            {
+                reference: start,
+                path: [
+                    ...origin.prefix
+                ],
+                dynamic: origin.dynamic,
+                depth: origin.depth
+            }
+        ];
+        const returnedFrom = new Set();
+        for(let flow = pending.pop(); flow; flow = pending.pop()){
+            let { reference, dynamic, depth } = flow;
+            const { path } = flow;
+            const holds = (holder, deeper)=>{
+                if (holder) add({
+                    binding: holder,
+                    prefix: path,
+                    dynamic,
+                    depth: depth + deeper
+                });
+            };
+            const into = (pattern, lookup)=>{
+                for (const identifier of Object.values(types_namespaceObject.getBindingIdentifiers(pattern))){
+                    const route = patternPath(pattern, identifier);
+                    const alias = lookup(identifier.name);
+                    if (void 0 === route || !alias) continue;
+                    if ('dynamic' === route) {
+                        add({
+                            binding: alias,
+                            prefix: path,
+                            dynamic: true,
+                            depth
+                        });
+                        continue;
+                    }
+                    const consumed = Math.min(depth, route.members.length);
+                    add({
+                        binding: alias,
+                        prefix: [
+                            ...path,
+                            ...route.members.slice(consumed)
+                        ],
+                        dynamic,
+                        depth: depth - consumed
+                    });
+                }
+            };
+            for(;;){
+                const parent = reference.parent;
+                const up = reference.parentPath;
+                if (!up) break;
+                if ((0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(parent, true) !== parent || types_namespaceObject.isConditionalExpression(parent) && parent.test !== reference.node || types_namespaceObject.isLogicalExpression(parent) || types_namespaceObject.isAwaitExpression(parent) || types_namespaceObject.isSequenceExpression(parent) && parent.expressions.at(-1) === reference.node) {
+                    reference = up;
+                    continue;
+                }
+                if ((types_namespaceObject.isMemberExpression(parent) || types_namespaceObject.isOptionalMemberExpression(parent)) && parent.object === reference.node) {
+                    if (depth > 0 && (types_namespaceObject.isCallExpression(up.parent) || types_namespaceObject.isOptionalCallExpression(up.parent)) && up.parent.callee === parent && CONTAINER_EXTRACTORS.has(staticKey(parent) ?? '')) {
+                        escaped = true;
+                        break;
+                    }
+                    if (0 === depth && (types_namespaceObject.isCallExpression(up.parent) || types_namespaceObject.isOptionalCallExpression(up.parent)) && up.parent.callee === parent && RECEIVER_RETURNING_METHODS.has(staticKey(parent) ?? '')) {
+                        reference = up.parentPath;
+                        continue;
+                    }
+                    if (depth > 0) depth -= 1;
+                    else {
+                        const name = staticKey(parent);
+                        if (void 0 === name) dynamic = true;
+                        else path.push(name);
+                    }
+                    reference = up;
+                    continue;
+                }
+                if (types_namespaceObject.isReturnStatement(parent) && parent.argument === reference.node || types_namespaceObject.isArrowFunctionExpression(parent) && parent.body === reference.node) {
+                    const fn = reference.getFunctionParent();
+                    if (fn && !returnedFrom.has(fn.node)) {
+                        returnedFrom.add(fn.node);
+                        const sites = callSitesOf(fn);
+                        escaped ||= sites.escaped;
+                        for (const call of sites.calls)pending.push({
+                            reference: call,
+                            path: [
+                                ...path
+                            ],
+                            dynamic,
+                            depth
+                        });
+                    }
+                    break;
+                }
+                if (types_namespaceObject.isForOfStatement(parent) && parent.right === reference.node || types_namespaceObject.isTemplateLiteral(parent) && types_namespaceObject.isTaggedTemplateExpression(up.parent) || types_namespaceObject.isJSXExpressionContainer(parent) || types_namespaceObject.isJSXSpreadAttribute(parent) || types_namespaceObject.isJSXSpreadChild(parent) || types_namespaceObject.isYieldExpression(parent)) {
+                    escaped = true;
+                    break;
+                }
+                if (types_namespaceObject.isObjectProperty(parent) && parent.value === reference.node && types_namespaceObject.isObjectExpression(up.parent) || types_namespaceObject.isSpreadElement(parent) && types_namespaceObject.isObjectExpression(up.parent)) {
+                    reference = up.parentPath;
+                    if (!types_namespaceObject.isSpreadElement(parent) || 0 === depth) depth += 1;
+                    continue;
+                }
+                if (types_namespaceObject.isArrayExpression(parent) || types_namespaceObject.isSpreadElement(parent) && types_namespaceObject.isArrayExpression(up.parent)) {
+                    reference = types_namespaceObject.isSpreadElement(parent) ? up.parentPath : up;
+                    if (!types_namespaceObject.isSpreadElement(parent) || 0 === depth) depth += 1;
+                    continue;
+                }
+                if (types_namespaceObject.isSpreadElement(parent)) {
+                    escaped = true;
+                    break;
+                }
+                if ((types_namespaceObject.isCallExpression(parent) || types_namespaceObject.isOptionalCallExpression(parent) || types_namespaceObject.isNewExpression(parent)) && parent.callee !== reference.node) {
+                    let calleePath = up.get('callee');
+                    while((0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(calleePath.node, true) !== calleePath.node)calleePath = calleePath.get('expression');
+                    const callee = calleePath.node;
+                    const member = types_namespaceObject.isMemberExpression(callee) || types_namespaceObject.isOptionalMemberExpression(callee);
+                    const receiver = member ? writeTarget(callee)?.root : void 0;
+                    if (receiver) holds(reference.scope.getBinding(receiver.name), 1);
+                    const receiverObject = member ? (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(callee.object, true) : void 0;
+                    const method = member && (types_namespaceObject.isIdentifier(receiverObject) || types_namespaceObject.isObjectExpression(receiverObject)) ? staticKey(callee) : void 0;
+                    let fn = types_namespaceObject.isIdentifier(callee) ? reference.scope.getBinding(callee.name) : types_namespaceObject.isIdentifier(receiverObject) ? reference.scope.getBinding(receiverObject.name) : void 0;
+                    for(let hop = 0; fn && hop < MAX_DEPTH; hop += 1){
+                        const aliased = fn.path.isVariableDeclarator() ? (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(fn.path.node.init ?? fn.path.node.id, true) : void 0;
+                        if ('const' !== fn.kind || !types_namespaceObject.isIdentifier(aliased)) break;
+                        const next = fn.path.scope.getBinding(aliased.name);
+                        if (!next || next === fn) break;
+                        fn = next;
+                    }
+                    const declared = fn?.path;
+                    const init = declared?.isVariableDeclarator() ? declared.get('init') : void 0;
+                    let literal = init;
+                    if (types_namespaceObject.isObjectExpression(receiverObject)) {
+                        literal = calleePath.get('object');
+                        while((0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(literal.node, true) !== literal.node)literal = literal.get('expression');
+                    }
+                    const lookup = void 0 !== method && literal?.isObjectExpression() ? methodOf(literal, method) : void 0;
+                    if ('unknown' === lookup) escaped = true;
+                    const property = 'unknown' === lookup ? void 0 : lookup;
+                    const held = property?.isObjectProperty() ? property.get('value') : property;
+                    const heldName = held?.isIdentifier() ? held.node.name : void 0;
+                    const heldFunction = heldName ? functionOf(held.scope.getBinding(heldName)) : void 0;
+                    const target = calleePath.isFunction() ? calleePath : void 0 !== method ? heldName ? heldFunction : held : declared?.isFunctionDeclaration() ? declared : init;
+                    if (heldName && !heldFunction?.isFunction()) {
+                        const binding = held.scope.getBinding(heldName);
+                        if (binding && 'module' !== binding.kind) escaped = true;
+                    }
+                    const initValue = init?.node ? (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(init.node, true) : void 0;
+                    const unseen = !target?.isFunction() && ([
+                        'param',
+                        'let',
+                        'var'
+                    ].includes(fn?.kind ?? '') || !types_namespaceObject.isIdentifier(callee) && !member || member && !types_namespaceObject.isIdentifier(receiverObject) && !types_namespaceObject.isObjectExpression(receiverObject) && (void 0 === receiver || reference.scope.getBinding(receiver.name)?.kind !== 'module') || void 0 !== method && fn?.kind === 'const' && !property && (types_namespaceObject.isNewExpression(initValue) || types_namespaceObject.isCallExpression(initValue)) && (()=>{
+                        const root = writeTarget((0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(initValue.callee, true))?.root;
+                        const owner = root ? fn.path.scope.getBinding(root.name) : void 0;
+                        return !root || void 0 !== owner && 'module' !== owner.kind;
+                    })() || fn?.kind === 'const' && void 0 === method && void 0 !== initValue && !types_namespaceObject.isMemberExpression(initValue) && !types_namespaceObject.isIdentifier(initValue));
+                    const globalName = types_namespaceObject.isIdentifier(callee) ? callee.name : member && types_namespaceObject.isIdentifier(receiverObject) ? receiverObject.name : void 0;
+                    const unboundGlobal = void 0 !== globalName && !reference.scope.getBinding(globalName) && !READ_ONLY_GLOBAL_CALLS.has(types_namespaceObject.isIdentifier(callee) ? globalName : `${globalName}.${staticKey(callee) ?? ''}`) && 'console' !== globalName;
+                    if (unseen || unboundGlobal) escaped = true;
+                    const index = parent.arguments.indexOf(reference.node);
+                    const storing = member && void 0 !== globalName && !reference.scope.getBinding(globalName) ? STORING_GLOBAL_CALLS.get(`${globalName}.${staticKey(callee) ?? ''}`) : void 0;
+                    if (storing && index >= 1) {
+                        const stored = parent.arguments[0] ? writeTarget(parent.arguments[0]) : void 0;
+                        const holder = stored ? reference.scope.getBinding(stored.root.name) : void 0;
+                        if (holder) holds(holder, stored.depth + storing(depth) - depth);
+                        else escaped = true;
+                    }
+                    if (('call' === method || 'apply' === method || 'bind' === method) && types_namespaceObject.isIdentifier(receiverObject)) {
+                        const receiverBinding = reference.scope.getBinding(receiverObject.name);
+                        const invoked = functionOf(receiverBinding);
+                        const param = invoked?.isFunction() ? invoked.node.params[index - 1] : void 0;
+                        if ('call' === method && index >= 1 && param && !types_namespaceObject.isRestElement(param) && invoked?.isFunction()) into(param, (name)=>invoked.scope.getBinding(name));
+                        else if (receiverBinding && 'module' !== receiverBinding.kind) escaped = true;
+                    }
+                    if (target?.isFunction()) {
+                        const param = target.node.params[index];
+                        if (param && !types_namespaceObject.isRestElement(param)) into(param, (name)=>target.scope.getBinding(name));
+                        else escaped = true;
+                    }
+                    reference = up;
+                    dynamic = true;
+                    continue;
+                }
+                if ((types_namespaceObject.isClassProperty(parent) || types_namespaceObject.isClassPrivateProperty(parent) || types_namespaceObject.isClassAccessorProperty(parent)) && parent.value === reference.node) {
+                    const owner = up.parentPath?.parentPath;
+                    if (!parent.static || types_namespaceObject.isPrivateName(parent.key) || !owner) {
+                        escaped = true;
+                        break;
+                    }
+                    if (owner.isClassDeclaration()) {
+                        const id = owner.node.id;
+                        const binding = id ? owner.parentPath.scope.getBinding(id.name) : void 0;
+                        if (binding) holds(binding, 1);
+                        else escaped = true;
+                        break;
+                    }
+                    reference = owner;
+                    depth += 1;
+                    continue;
+                }
+                if (types_namespaceObject.isAssignmentExpression(parent) && parent.right === reference.node && !types_namespaceObject.isIdentifier(parent.left) && !types_namespaceObject.isPattern(parent.left)) {
+                    const stored = writeTarget(parent.left);
+                    const setters = setterNames(reference.scope.getProgramParent().path);
+                    const key = types_namespaceObject.isMemberExpression(parent.left) || types_namespaceObject.isOptionalMemberExpression(parent.left) ? staticKey(parent.left) : void 0;
+                    if (setters.has(DYNAMIC_SETTER) || setters.size > 0 && (void 0 === key || setters.has(key))) {
+                        escaped = true;
+                        break;
+                    }
+                    if (stored) holds(reference.scope.getBinding(stored.root.name), stored.depth);
+                    reference = up;
+                    continue;
+                }
+                break;
+            }
+            const parent = reference.parent;
+            const target = types_namespaceObject.isVariableDeclarator(parent) && parent.init === reference.node ? parent.id : types_namespaceObject.isAssignmentExpression(parent) && [
+                '=',
+                '&&=',
+                '||=',
+                '??='
+            ].includes(parent.operator) || types_namespaceObject.isAssignmentPattern(parent) ? parent.right === reference.node ? parent.left : void 0 : void 0;
+            if (types_namespaceObject.isLVal(target)) {
+                into(target, (name)=>reference.scope.getBinding(name));
+                if (types_namespaceObject.isAssignmentExpression(parent) && reference.parentPath) pending.push({
+                    reference: reference.parentPath,
+                    path: [
+                        ...path
+                    ],
+                    dynamic,
+                    depth
+                });
+            }
+        }
+    }
+    const reaches = (entry)=>(writes.get(entry.binding) ?? []).some((write)=>0 === entry.depth ? entry.dynamic : write.depth > entry.depth);
+    const tracked = new Set(found.map((entry)=>entry.binding));
+    if (found.length > MAX_ALIASES || found.some(reaches) || escaped && [
+        ...writes.keys()
+    ].some((owner)=>!tracked.has(owner))) return;
+    return found.filter((entry)=>!entry.dynamic && 0 === entry.depth);
+};
+function createModuleGraph() {
+    const modules = new Map();
+    const facts = new WeakMap();
+    const workspaces = new Map();
+    const load = (filePath, boundary)=>{
+        const real = external_node_fs_default().realpathSync(filePath);
+        let entry = modules.get(real);
+        if (void 0 === entry) {
+            const directory = external_node_path_default().dirname(real);
+            if (!workspaces.has(directory)) workspaces.set(directory, containingWorkspace(real));
+            const workspace = workspaces.get(directory);
+            try {
+                const parsed = parseModule(real, workspace);
+                const module = {
+                    file: parsed.file,
+                    path: real,
+                    boundary: boundary ?? sourceBoundary(real, workspace),
+                    mutations: parsed.mutations
+                };
+                facts.set(module, parsed.facts);
+                entry = {
+                    module,
+                    facts: parsed.facts
+                };
+            } catch (error) {
+                if (!(error instanceof external_source_analysis_cjs_namespaceObject.SourceSyntaxError)) throw error;
+                entry = error;
+            }
+            modules.set(real, entry);
+        }
+        if (entry instanceof external_source_analysis_cjs_namespaceObject.SourceSyntaxError) throw entry;
+        return entry.module;
+    };
+    const factsOf = (module)=>{
+        const known = facts.get(module);
+        if (known) return known;
+        throw new Error(`${module.path}: module does not belong to this graph`);
+    };
+    const follow = (module, specifier)=>{
+        const target = resolveModulePath(module, specifier, factsOf(module).workspace);
+        if (target?.kind === 'external') return 'external';
+        if (void 0 === target) return;
+        try {
+            return load(target.path, target.boundary);
+        } catch (error) {
+            if (error instanceof external_source_analysis_cjs_namespaceObject.SourceSyntaxError) return;
+            throw error;
+        }
+    };
+    const mutated = (module, binding)=>binding.constantViolations.length > 0 || factsOf(module).merged.has(binding.identifier.name) || (aliasesOf(binding, factsOf(module).writes)?.some((alias)=>factsOf(module).writes.has(alias.binding)) ?? true);
+    const resolveBinding = (module, name, scope, chain, seen, lexical)=>{
+        const key = `${scope}:${module.path}#${name}`;
+        if (seen.has(key) || seen.size >= MAX_LOOKUPS) return;
+        seen.add(key);
+        const last = chain.at(-1);
+        const hops = last?.path === module.path && last.name === name ? chain : [
+            ...chain,
+            {
+                path: module.path,
+                name
+            }
+        ];
+        const throughModule = (specifier, imported, allowExternal)=>{
+            const next = follow(module, specifier);
+            if ('external' === next) return allowExternal ? {
+                kind: 'external',
+                specifier,
+                name: imported,
+                chain: hops
+            } : void 0;
+            return void 0 === next ? void 0 : resolveBinding(next, imported, 'export', hops, seen);
+        };
+        if ('local' === scope) {
+            const binding = lexical ?? factsOf(module).scope.getBinding(name);
+            if (!binding || mutated(module, binding)) return;
+            if ('module' === binding.kind) {
+                const imported = importOf(binding);
+                return void 0 === imported || '*' === imported.name ? void 0 : throughModule(imported.specifier, imported.name, true);
+            }
+            const declarator = binding.path.node;
+            return 'const' === binding.kind && types_namespaceObject.isVariableDeclarator(declarator) && types_namespaceObject.isIdentifier(declarator.id) && declarator.init ? {
+                kind: 'declaration',
+                expression: declarator.init,
+                module,
+                chain: hops
+            } : void 0;
+        }
+        const hop = exportHop(module.file, name);
+        if (hop?.kind === 'local') return resolveBinding(module, hop.name, 'local', hops, seen);
+        if (hop?.kind === 'reexport') return throughModule(hop.specifier, hop.name, true);
+        if (hop?.kind === 'node') return types_namespaceObject.isExpression(hop.node) ? {
+            kind: 'declaration',
+            expression: hop.node,
+            module,
+            chain: hops
+        } : void 0;
+        if (void 0 !== hop) return;
+        for (const specifier of starSources(module.file, name)){
+            const resolved = throughModule(specifier, name, false);
+            if (void 0 !== resolved) return resolved;
+        }
+    };
+    const resolveReference = (module, reference)=>{
+        const node = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(reference, true);
+        const moduleFacts = factsOf(module);
+        const bindingAt = (identifier)=>moduleFacts.references.get(identifier) ?? moduleFacts.declarations.get(identifier);
+        if (types_namespaceObject.isIdentifier(node)) {
+            const binding = bindingAt(node);
+            return binding ? resolveBinding(module, node.name, 'local', [], new Set(), binding) : void 0;
+        }
+        if (!types_namespaceObject.isMemberExpression(node) || node.computed || !types_namespaceObject.isIdentifier(node.object) || !types_namespaceObject.isIdentifier(node.property)) return;
+        const binding = bindingAt(node.object);
+        if (!binding || 'module' !== binding.kind || mutated(module, binding)) return;
+        const imported = importOf(binding);
+        if (imported?.name !== '*') return;
+        const target = follow(module, imported.specifier);
+        const chain = [
+            {
+                path: module.path,
+                name: node.object.name
+            }
+        ];
+        if ('external' === target) return {
+            kind: 'external',
+            specifier: imported.specifier,
+            name: node.property.name,
+            chain
+        };
+        return void 0 === target ? void 0 : resolveBinding(target, node.property.name, 'export', chain, new Set());
+    };
+    const isUnboundReference = (module, reference)=>{
+        const node = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(reference, true);
+        const { references } = factsOf(module);
+        return types_namespaceObject.isIdentifier(node) && references.has(node) && void 0 === references.get(node);
+    };
+    const evaluation = (walking)=>{
+        const active = new Set();
+        let frames = 0;
+        let frame = {
+            id: 0,
+            parameters: new Map()
+        };
+        let steps = 0;
+        const boundArguments = new WeakMap();
+        const closureFrames = new WeakMap();
+        const unresolved = (module, node)=>[
+                {
+                    kind: 'unresolved',
+                    node,
+                    module
+                }
+            ];
+        const namespaceValues = (module, specifier, members, at)=>{
+            const next = follow(module, specifier);
+            if ('external' === next) return [
+                0 === members.length ? {
+                    kind: 'external',
+                    specifier,
+                    name: '*',
+                    members: []
+                } : {
+                    kind: 'external',
+                    specifier,
+                    name: members[0],
+                    members: members.slice(1)
+                }
+            ];
+            if (void 0 === next) return unresolved(module, at);
+            if (0 === members.length) {
+                const written = (write)=>write.value ? values(next, write.value, [
+                        ...write.from ?? []
+                    ]) : unresolved(next, write.node);
+                const whole = factsOf(next).commonJs.filter((write)=>0 === write.path.length && !write.dynamic);
+                const found = whole.flatMap(written);
+                if (walking) {
+                    for (const write of factsOf(next).commonJs)if (write.path.length > 0 || write.dynamic) found.push(...written(write));
+                    const key = `namespace:${next.path}`;
+                    if (!active.has(key)) {
+                        active.add(key);
+                        try {
+                            for (const name of exportNames(next.file))found.push(...exportValues(next, name, []) ?? []);
+                            for (const specifier of starSources(next.file, ''))found.push(...namespaceValues(next, specifier, [], at));
+                        } finally{
+                            active.delete(key);
+                        }
+                    }
+                }
+                return whole.length > 0 ? found : [
+                    ...unresolved(module, at),
+                    ...found
+                ];
+            }
+            return exportValues(next, members[0], members.slice(1)) ?? unresolved(module, at);
+        };
+        const importValues = (module, specifier, name, members, at)=>{
+            if ('*' === name) return namespaceValues(module, specifier, members, at);
+            const next = follow(module, specifier);
+            if ('external' === next) return [
+                {
+                    kind: 'external',
+                    specifier,
+                    name,
+                    members
+                }
+            ];
+            return (next && exportValues(next, name, members)) ?? unresolved(module, at);
+        };
+        const exportValues = (module, name, members)=>{
+            const key = `export:${module.path}#${name}:${members.join('.')}`;
+            if (active.has(key)) return;
+            if (++steps > MAX_LOOKUPS || active.size >= MAX_DEPTH) return unresolved(module, module.file);
+            active.add(key);
+            try {
+                return exportedValues(module, name, members);
+            } finally{
+                active.delete(key);
+            }
+        };
+        const exportedValues = (module, name, members)=>{
+            const hop = exportHop(module.file, name);
+            if (hop?.kind === 'local') {
+                const binding = factsOf(module).scope.getBinding(hop.name);
+                return binding ? bindingValues(module, binding, members, binding.identifier) : unresolved(module, module.file);
+            }
+            if (hop?.kind === 'reexport') return importValues(module, hop.specifier, hop.name, members, module.file);
+            if (hop?.kind === 'namespace') return namespaceValues(module, hop.specifier, members, module.file);
+            if (hop?.kind === 'node') return values(module, hop.node, members);
+            for (const specifier of starSources(module.file, name)){
+                const next = follow(module, specifier);
+                const found = void 0 === next || 'external' === next ? void 0 : exportValues(next, name, members);
+                if (void 0 !== found) return found;
+            }
+            return commonJsExport(module, name, members);
+        };
+        const commonJsExport = (module, name, members)=>{
+            const found = [];
+            for (const [requested, explicit] of 'default' === name ? [
+                [
+                    [
+                        ...members
+                    ],
+                    false
+                ],
+                [
+                    [
+                        'default',
+                        ...members
+                    ],
+                    true
+                ]
+            ] : [
+                [
+                    [
+                        name,
+                        ...members
+                    ],
+                    false
+                ]
+            ])for (const write of factsOf(module).commonJs){
+                if (explicit && 0 === write.path.length) continue;
+                const reads = write.path.length <= requested.length;
+                const [shorter, longer] = reads ? [
+                    write.path,
+                    requested
+                ] : [
+                    requested,
+                    write.path
+                ];
+                if (!(!reads && !walking || shorter.some((key, index)=>longer[index] !== key))) found.push(...write.dynamic || !write.value ? unresolved(module, write.node) : values(module, write.value, [
+                    ...write.from ?? [],
+                    ...reads ? requested.slice(write.path.length) : []
+                ]));
+            }
+            return found.length > 0 ? found : void 0;
+        };
+        const bindingValues = (module, binding, members, at)=>{
+            const moduleFacts = factsOf(module);
+            if (binding.scope === moduleFacts.scope && moduleFacts.merged.has(binding.identifier.name)) return unresolved(module, at);
+            const found = [];
+            const node = binding.path.node;
+            if ('module' === binding.kind) {
+                const imported = importOf(binding);
+                found.push(...void 0 === imported ? unresolved(module, at) : importValues(module, imported.specifier, imported.name, members, binding.path.parent));
+            } else if (types_namespaceObject.isVariableDeclarator(node)) {
+                const route = patternPath(node.id, binding.identifier);
+                const rest = 'dynamic' === route && node.init && members.length > 0 ? objectRestPath(node.id, binding.identifier) : void 0;
+                if (rest && !rest.excluded.has(members[0])) found.push(...values(module, node.init, [
+                    ...rest.members,
+                    ...members
+                ]));
+                else if (void 0 === route || 'dynamic' === route) found.push(...unresolved(module, at));
+                else {
+                    if (node.init) found.push(...values(module, node.init, [
+                        ...route.members,
+                        ...members
+                    ]));
+                    else if (0 === binding.constantViolations.length || types_namespaceObject.isForXStatement(binding.path.parentPath?.parent)) found.push(...unresolved(module, at));
+                    for (const fallback of route.defaults)found.push(...values(module, fallback.value, [
+                        ...route.members.slice(fallback.members.length),
+                        ...members
+                    ]));
+                }
+            } else if (types_namespaceObject.isClassDeclaration(node) && members.length > 0) found.push(...staticMemberValues(module, node, members));
+            else if (types_namespaceObject.isFunctionDeclaration(node) || types_namespaceObject.isClassDeclaration(node)) found.push(...0 === members.length ? [
+                {
+                    kind: 'node',
+                    node,
+                    module
+                }
+            ] : unresolved(module, at));
+            else {
+                const parameter = 'param' === binding.kind ? frame.parameters.get(binding) : void 0;
+                const route = parameter ? patternPath(parameter.pattern, binding.identifier) : void 0;
+                if (parameter && route && 'dynamic' !== route) {
+                    const { argument } = parameter;
+                    if (argument) {
+                        const current = frame;
+                        frame = parameter.context;
+                        try {
+                            found.push(...values(argument.module, argument.node, [
+                                ...route.members,
+                                ...members
+                            ]));
+                        } finally{
+                            frame = current;
+                        }
+                    } else if (0 === route.defaults.length) found.push(...unresolved(module, at));
+                    for (const fallback of route.defaults)found.push(...values(module, fallback.value, [
+                        ...route.members.slice(fallback.members.length),
+                        ...members
+                    ]));
+                } else found.push(...unresolved(module, at));
+            }
+            for (const violation of binding.constantViolations){
+                const write = violation.node;
+                const target = types_namespaceObject.isAssignmentExpression(write) && [
+                    '=',
+                    '&&=',
+                    '||=',
+                    '??='
+                ].includes(write.operator) ? types_namespaceObject.getBindingIdentifiers(write.left)[binding.identifier.name] : void 0;
+                const route = target && types_namespaceObject.isAssignmentExpression(write) ? patternPath(write.left, target) : void 0;
+                if (!route || 'dynamic' === route || !types_namespaceObject.isAssignmentExpression(write)) {
+                    found.push(...unresolved(module, write));
+                    continue;
+                }
+                found.push(...values(module, write.right, [
+                    ...route.members,
+                    ...members
+                ]));
+                for (const fallback of route.defaults)found.push(...values(module, fallback.value, [
+                    ...route.members.slice(fallback.members.length),
+                    ...members
+                ]));
+            }
+            const aliases = aliasesOf(binding, moduleFacts.writes);
+            if (!aliases) found.push(...unresolved(module, at));
+            for (const write of (aliases ?? []).flatMap((alias)=>(moduleFacts.writes.get(alias.binding) ?? []).map((entry)=>({
+                        ...entry,
+                        path: [
+                            ...alias.prefix,
+                            ...entry.path
+                        ]
+                    })))){
+                const reads = write.dynamic ? write.path.length < members.length : write.path.length <= members.length;
+                const [shorter, longer] = reads ? [
+                    write.path,
+                    members
+                ] : [
+                    members,
+                    write.path
+                ];
+                if (!(!reads && !walking || shorter.some((name, index)=>longer[index] !== name))) {
+                    if (write.dynamic && reads) found.push(...unresolved(module, write.node));
+                    found.push(...void 0 === write.value ? unresolved(module, write.node) : values(module, write.value, [
+                        ...write.from ?? [],
+                        ...reads ? members.slice(write.path.length + (write.dynamic ? 1 : 0)) : []
+                    ]));
+                }
+            }
+            return found;
+        };
+        const propertyValues = (module, object, members)=>{
+            const [name, ...rest] = members;
+            const found = [];
+            for (const property of object.properties.toReversed()){
+                if (types_namespaceObject.isSpreadElement(property)) {
+                    found.push(values(module, property.argument, members));
+                    const spread = values(module, property.argument, []);
+                    if (void 0 !== name && spread.length > 0 && spread.every((value)=>'node' === value.kind && types_namespaceObject.isObjectExpression(value.node) && value.node.properties.some((entry)=>!types_namespaceObject.isSpreadElement(entry) && (staticKey(entry) ?? (entry.computed ? constantString(value.module, entry.key) : void 0)) === name && !(types_namespaceObject.isObjectMethod(entry) && 'set' === entry.kind)))) break;
+                    continue;
+                }
+                const key = staticKey(property) ?? (property.computed ? constantString(module, property.key) : void 0);
+                if (void 0 === key) {
+                    found.push(unresolved(module, property));
+                    continue;
+                }
+                if (key === name) {
+                    found.push(types_namespaceObject.isObjectMethod(property) ? 'get' === property.kind ? returnValues(module, property, rest) : 0 === rest.length ? [
+                        {
+                            kind: 'node',
+                            node: property,
+                            module
+                        }
+                    ] : unresolved(module, property) : values(module, property.value, rest));
+                    if (!types_namespaceObject.isObjectMethod(property) || 'set' !== property.kind) break;
+                }
+            }
+            const ordered = found.toReversed().flat();
+            return ordered.length > 0 ? ordered : unresolved(module, object);
+        };
+        const staticMemberValues = (module, declaration, members)=>{
+            const [name, ...rest] = members;
+            const found = [];
+            let definite = false;
+            for (const member of declaration.body.body.toReversed()){
+                if (definite) break;
+                if (types_namespaceObject.isStaticBlock(member)) {
+                    found.push(...unresolved(module, member));
+                    continue;
+                }
+                if (!(types_namespaceObject.isClassProperty(member) || types_namespaceObject.isClassAccessorProperty(member) || types_namespaceObject.isClassMethod(member)) || !member.static) continue;
+                const key = staticKey(member) ?? (member.computed ? constantString(module, member.key) : void 0);
+                if (void 0 === key) {
+                    found.push(...unresolved(module, member));
+                    continue;
+                }
+                if (key === name) {
+                    if (types_namespaceObject.isClassProperty(member) || types_namespaceObject.isClassAccessorProperty(member)) {
+                        definite = true;
+                        found.push(...member.value ? values(module, member.value, rest) : unresolved(module, member));
+                    } else if ('get' === member.kind) {
+                        definite = true;
+                        found.push(...returnValues(module, member, rest));
+                    } else if ('method' === member.kind) {
+                        definite = true;
+                        found.push(...0 === rest.length ? [
+                            {
+                                kind: 'node',
+                                node: member,
+                                module
+                            }
+                        ] : unresolved(module, member));
+                    }
+                }
+            }
+            if (!definite || declaration.superClass) found.push(...unresolved(module, declaration));
+            return found;
+        };
+        const returnValues = (module, fn, members)=>{
+            const body = fn.body;
+            if (types_namespaceObject.isExpression(body)) return values(module, body, members);
+            const moduleFacts = factsOf(module);
+            const found = moduleFacts.bareReturns.has(fn) || !(types_namespaceObject.isReturnStatement(body.body.at(-1)) || types_namespaceObject.isThrowStatement(body.body.at(-1))) ? unresolved(module, fn) : [];
+            for (const expression of moduleFacts.returns.get(fn) ?? [])found.push(...values(module, expression, members));
+            return found;
+        };
+        const callable = (value)=>'external' === value.kind || 'node' === value.kind && types_namespaceObject.isFunction(value.node);
+        const callValues = (module, call, members)=>{
+            const found = [];
+            let terminal = false;
+            const argumentsOf = (args)=>args.map((node)=>({
+                        module,
+                        node,
+                        context: frame
+                    }));
+            const run = (callee, callArgs)=>{
+                const args = [
+                    ...boundArguments.get(callee) ?? [],
+                    ...callArgs
+                ];
+                if ('unresolved' === callee.kind) return void found.push(...unresolved(module, call));
+                if ('node' !== callee.kind || !types_namespaceObject.isFunction(callee.node)) {
+                    terminal = true;
+                    return;
+                }
+                const outer = frame;
+                const parameters = new Map([
+                    ...outer.parameters,
+                    ...closureFrames.get(callee)?.parameters ?? []
+                ]);
+                const fnScope = factsOf(callee.module).functionScopes.get(callee.node);
+                const spread = args.findIndex(({ node })=>types_namespaceObject.isSpreadElement(node) || types_namespaceObject.isArgumentPlaceholder(node));
+                callee.node.params.forEach((param, index)=>{
+                    if (-1 !== spread && index >= spread) return;
+                    const remaining = args.slice(index);
+                    const restArray = types_namespaceObject.isRestElement(param) && types_namespaceObject.isIdentifier(param.argument) && remaining.every(({ module: from, context })=>from === remaining[0]?.module && context === remaining[0]?.context) ? {
+                        ...types_namespaceObject.arrayExpression(remaining.map(({ node })=>node)),
+                        start: param.start,
+                        end: param.end
+                    } : void 0;
+                    if (restArray && types_namespaceObject.isRestElement(param)) {
+                        const binding = fnScope?.getOwnBinding(param.argument.name);
+                        if (binding) parameters.set(binding, {
+                            pattern: param.argument,
+                            argument: {
+                                module: remaining[0]?.module ?? module,
+                                node: restArray
+                            },
+                            context: remaining[0]?.context ?? outer
+                        });
+                        return;
+                    }
+                    const argument = args[index];
+                    for (const name of Object.keys(types_namespaceObject.getBindingIdentifiers(param))){
+                        const binding = fnScope?.getOwnBinding(name);
+                        if (binding) parameters.set(binding, {
+                            pattern: param,
+                            argument: argument ? {
+                                module: argument.module,
+                                node: argument.node
+                            } : void 0,
+                            context: argument?.context ?? outer
+                        });
+                    }
+                });
+                const inner = {
+                    id: frames += 1,
+                    parameters
+                };
+                frame = inner;
+                try {
+                    for (const value of returnValues(callee.module, callee.node, members))if ('node' === value.kind && types_namespaceObject.isFunction(value.node)) {
+                        const closure = {
+                            ...value
+                        };
+                        closureFrames.set(closure, inner);
+                        const bound = boundArguments.get(value);
+                        if (bound) boundArguments.set(closure, bound);
+                        found.push(closure);
+                    } else found.push(value);
+                } finally{
+                    frame = outer;
+                }
+            };
+            const via = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(call.callee, true);
+            const invocation = (types_namespaceObject.isMemberExpression(via) || types_namespaceObject.isOptionalMemberExpression(via)) && [
+                'call',
+                'apply',
+                'bind'
+            ].includes(staticKey(via) ?? '') ? {
+                name: staticKey(via),
+                object: via.object
+            } : void 0;
+            const reflected = (types_namespaceObject.isMemberExpression(via) || types_namespaceObject.isOptionalMemberExpression(via)) && types_namespaceObject.isIdentifier(via.object, {
+                name: 'Reflect'
+            }) && 'apply' === staticKey(via) && !(factsOf(module).references.get(via.object) ?? factsOf(module).scope.getBinding('Reflect')) && void 0 !== call.arguments[0];
+            if (reflected) {
+                const listed = call.arguments[2];
+                const list = types_namespaceObject.isArrayExpression(listed) && listed.elements.every((element)=>null !== element && !types_namespaceObject.isSpreadElement(element)) ? listed.elements : void 0;
+                for (const callee of values(module, call.arguments[0], []))if (list) run(callee, argumentsOf(list));
+                else found.push(...unresolved(module, call));
+            } else if (invocation) {
+                const receivers = values(module, invocation.object, []);
+                if (!receivers.every(callable)) for (const callee of values(module, invocation.object, [
+                    invocation.name
+                ]))run(callee, argumentsOf(call.arguments));
+                for (const receiver of receivers.filter(callable)){
+                    if ('bind' === invocation.name) {
+                        if (members.length > 0) {
+                            found.push(...unresolved(module, call));
+                            continue;
+                        }
+                        const bound = argumentsOf(call.arguments.slice(1));
+                        if (0 === bound.length) {
+                            found.push(receiver);
+                            continue;
+                        }
+                        const boundReceiver = {
+                            ...receiver
+                        };
+                        const closure = closureFrames.get(receiver);
+                        if (closure) closureFrames.set(boundReceiver, closure);
+                        boundArguments.set(boundReceiver, [
+                            ...boundArguments.get(receiver) ?? [],
+                            ...bound
+                        ]);
+                        found.push(boundReceiver);
+                        continue;
+                    }
+                    const listed = call.arguments[1];
+                    run(receiver, argumentsOf('call' === invocation.name ? call.arguments.slice(1) : types_namespaceObject.isArrayExpression(listed) && listed.elements.every((element)=>null !== element && !types_namespaceObject.isSpreadElement(element)) ? listed.elements : []));
+                }
+            } else for (const callee of values(module, call.callee, []))run(callee, argumentsOf(call.arguments));
+            if (terminal) found.push(...0 === members.length ? [
+                {
+                    kind: 'node',
+                    node: call,
+                    module
+                }
+            ] : unresolved(module, call));
+            return found;
+        };
+        const constantString = (module, expression, depth = 0)=>{
+            const node = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(expression, true);
+            if (depth > MAX_DEPTH) return;
+            if (types_namespaceObject.isStringLiteral(node)) return node.value;
+            if (types_namespaceObject.isNumericLiteral(node)) return String(node.value);
+            if (types_namespaceObject.isTemplateLiteral(node) && 0 === node.expressions.length) return node.quasis[0]?.value.cooked ?? void 0;
+            if (types_namespaceObject.isBinaryExpression(node, {
+                operator: '+'
+            })) {
+                const left = constantString(module, node.left, depth + 1);
+                const right = constantString(module, node.right, depth + 1);
+                return void 0 === left || void 0 === right ? void 0 : left + right;
+            }
+            if (!types_namespaceObject.isIdentifier(node)) return;
+            const binding = factsOf(module).references.get(node) ?? factsOf(module).scope.getBinding(node.name);
+            const declarator = binding?.path.node;
+            return binding?.kind === 'const' && types_namespaceObject.isVariableDeclarator(declarator) && declarator.id === binding.identifier && declarator.init ? constantString(module, declarator.init, depth + 1) : void 0;
+        };
+        const values = (module, expression, members)=>{
+            const node = (0, external_source_analysis_cjs_namespaceObject.unwrapExpression)(expression, true);
+            const key = `${frame.id}:${module.path}:${node.start}:${node.end}:${node.type}:${members.join('.')}`;
+            if (active.has(key)) return unresolved(module, node);
+            if (++steps > MAX_LOOKUPS || active.size >= MAX_DEPTH) return unresolved(module, node);
+            active.add(key);
+            try {
+                if (types_namespaceObject.isIdentifier(node) || types_namespaceObject.isJSXIdentifier(node)) {
+                    const binding = factsOf(module).references.get(node) ?? factsOf(module).scope.getBinding(node.name);
+                    return binding ? bindingValues(module, binding, members, node) : unresolved(module, node);
+                }
+                if (types_namespaceObject.isJSXMemberExpression(node)) return values(module, node.object, [
+                    node.property.name,
+                    ...members
+                ]);
+                if (types_namespaceObject.isMemberExpression(node) || types_namespaceObject.isOptionalMemberExpression(node)) {
+                    const name = staticKey(node) ?? (node.computed ? constantString(module, node.property) : void 0);
+                    if (void 0 === name) return unresolved(module, node);
+                    if (0 === members.length && [
+                        'call',
+                        'apply',
+                        'bind'
+                    ].includes(name)) {
+                        const receivers = values(module, node.object, []);
+                        const functions = receivers.filter(callable);
+                        return functions.length === receivers.length ? functions : [
+                            ...functions,
+                            ...values(module, node.object, [
+                                name
+                            ])
+                        ];
+                    }
+                    return values(module, node.object, [
+                        name,
+                        ...members
+                    ]);
+                }
+                if (types_namespaceObject.isImportExpression(node) && types_namespaceObject.isStringLiteral(node.source)) return namespaceValues(module, node.source.value, members, node);
+                if (types_namespaceObject.isCallExpression(node) && types_namespaceObject.isIdentifier(node.callee, {
+                    name: 'require'
+                }) && !(factsOf(module).references.has(node.callee) ? factsOf(module).references.get(node.callee) : factsOf(module).scope.getBinding('require')) && 1 === node.arguments.length && types_namespaceObject.isStringLiteral(node.arguments[0])) return namespaceValues(module, node.arguments[0].value, members, node);
+                if (types_namespaceObject.isCallExpression(node) || types_namespaceObject.isOptionalCallExpression(node)) return callValues(module, node, members);
+                if (types_namespaceObject.isConditionalExpression(node)) return [
+                    ...values(module, node.consequent, members),
+                    ...values(module, node.alternate, members)
+                ];
+                if (types_namespaceObject.isLogicalExpression(node)) return [
+                    ...values(module, node.left, members),
+                    ...values(module, node.right, members)
+                ];
+                if (types_namespaceObject.isAwaitExpression(node)) return values(module, node.argument, members);
+                if (types_namespaceObject.isAssignmentExpression(node)) return '=' === node.operator ? values(module, node.right, members) : [
+                    '&&=',
+                    '||=',
+                    '??='
+                ].includes(node.operator) ? [
+                    ...values(module, node.left, members),
+                    ...values(module, node.right, members)
+                ] : unresolved(module, node);
+                if (types_namespaceObject.isSequenceExpression(node)) return values(module, node.expressions.at(-1), members);
+                if (0 === members.length) return [
+                    {
+                        kind: 'node',
+                        node,
+                        module
+                    }
+                ];
+                if (types_namespaceObject.isObjectExpression(node)) return propertyValues(module, node, members);
+                if (types_namespaceObject.isClassExpression(node) || types_namespaceObject.isClassDeclaration(node)) return staticMemberValues(module, node, members);
+                const [index, ...rest] = members;
+                const element = types_namespaceObject.isArrayExpression(node) && void 0 !== index && /^\d+$/u.test(index) ? node.elements.slice(0, Number(index) + 1) : void 0;
+                return element && element.length === Number(index) + 1 && !element.some((item)=>types_namespaceObject.isSpreadElement(item)) && element.at(-1) ? values(module, element.at(-1), rest) : unresolved(module, node);
+            } finally{
+                active.delete(key);
+            }
+        };
+        const reachable = (module, expression)=>{
+            const found = [];
+            const walked = new Set();
+            const pending = [
+                [
+                    module,
+                    expression
+                ]
+            ];
+            const walk = (owner, node)=>pending.push([
+                    owner,
+                    node
+                ]);
+            for(let next = pending.pop(); next; next = pending.pop()){
+                const [owner, node] = next;
+                const key = `${owner.path}:${node.start}:${node.end}:${node.type}`;
+                if (walked.has(key)) continue;
+                walked.add(key);
+                if (walked.size > MAX_LOOKUPS) {
+                    found.push(...unresolved(owner, node));
+                    continue;
+                }
+                const reference = (types_namespaceObject.isIdentifier(node) || types_namespaceObject.isJSXIdentifier(node)) && factsOf(owner).references.has(node) || types_namespaceObject.isJSXMemberExpression(node) || types_namespaceObject.isMemberExpression(node) || types_namespaceObject.isOptionalMemberExpression(node);
+                const call = types_namespaceObject.isCallExpression(node) || types_namespaceObject.isOptionalCallExpression(node);
+                if (reference || call) {
+                    steps = 0;
+                    const evaluated = values(owner, node, []);
+                    for (const value of evaluated)if ('node' !== value.kind) found.push(value);
+                    else if (value.node !== node) walk(value.module, value.node);
+                    if (reference) {
+                        if ((types_namespaceObject.isMemberExpression(node) || types_namespaceObject.isOptionalMemberExpression(node) || types_namespaceObject.isJSXMemberExpression(node)) && evaluated.some((value)=>'unresolved' === value.kind)) {
+                            walk(owner, node.object);
+                            if (!types_namespaceObject.isJSXMemberExpression(node) && node.computed) walk(owner, node.property);
+                        }
+                        continue;
+                    }
+                }
+                if (!(types_namespaceObject.isIdentifier(node) || node.type.startsWith('TS') && !types_namespaceObject.isExpression(node))) for (const field of types_namespaceObject.VISITOR_KEYS[node.type] ?? []){
+                    if (/^(?:typeAnnotation|returnType|typeParameters|typeArguments|superTypeParameters)$/u.test(field)) continue;
+                    const child = node[field];
+                    for (const item of Array.isArray(child) ? child : [
+                        child
+                    ])if (types_namespaceObject.isNode(item)) walk(owner, item);
+                }
+            }
+            return found;
+        };
+        return {
+            values,
+            reachable
+        };
+    };
+    return {
+        module: (filePath)=>load(filePath),
+        resolve: (module, name, scope)=>resolveBinding(module, name, scope, [], new Set()),
+        resolveReference,
+        isUnboundReference,
+        evaluate: (module, expression)=>evaluation(false).values(module, expression, []),
+        reachable: (module, expression)=>evaluation(true).reachable(module, expression)
+    };
+}
+exports.createModuleGraph = __webpack_exports__.createModuleGraph;
+exports.exportedConst = __webpack_exports__.exportedConst;
+exports.localConst = __webpack_exports__.localConst;
+exports.propertyName = __webpack_exports__.propertyName;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModuleGraph",
+    "exportedConst",
+    "localConst",
+    "propertyName"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});