optiprune 2.1.4 → 2.1.7

package/dist/parser.js

@@ -1,832 +0,0 @@
-import { parse as yukuParse, langFromPath, sourceTypeFromPath } from "yuku-parser";
-function isNode(value) {
-    return value !== null && typeof value === "object" && typeof value.type === "string";
-}
-function asArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-// yuku-parser nodes carry byte offsets (start/end) but no loc object.
-// We compute line/column from the source text when needed.
-let _yukuSource = "";
-function setYukuSource(src) { _yukuSource = src; }
-function offsetToPosition(offset) {
-    const before = _yukuSource.slice(0, Math.max(0, offset));
-    const line = before.split("\n").length;
-    const lastNewline = before.lastIndexOf("\n");
-    const column = lastNewline === -1 ? before.length : before.length - lastNewline - 1;
-    return { line, column };
-}
-function positionRange(node) {
-    if (!node)
-        return undefined;
-    // Prefer pre-existing loc (e.g. from Babel-compatible AST shims)
-    if (node.loc?.start && node.loc?.end) {
-        const s = node.loc.start;
-        const e = node.loc.end;
-        return {
-            start: { line: s.line, column: s.column },
-            end: { line: e.line, column: e.column },
-        };
-    }
-    // Fall back to computing from yuku-parser byte offsets
-    if (typeof node.start === "number" && typeof node.end === "number") {
-        return {
-            start: offsetToPosition(node.start),
-            end: offsetToPosition(node.end),
-        };
-    }
-    return undefined;
-}
-function locationAtOffset(source, offset) {
-    const before = source.slice(0, Math.max(0, offset));
-    const line = before.split("\n").length;
-    const lastNewline = before.lastIndexOf("\n");
-    const column = lastNewline === -1 ? before.length : before.length - lastNewline - 1;
-    return {
-        start: { line, column },
-        end: { line, column: column + 1 },
-    };
-}
-function nodeStringValue(node) {
-    if (!isNode(node)) {
-        return undefined;
-    }
-    if ((node.type === "StringLiteral" || node.type === "Literal") && typeof node.value === "string") {
-        return node.value;
-    }
-    return undefined;
-}
-function nodeIdentifierName(node) {
-    if (!isNode(node)) {
-        return undefined;
-    }
-    if (node.type === "Identifier" && typeof node.name === "string") {
-        return node.name;
-    }
-    return undefined;
-}
-function propertyKeyName(node) {
-    if (!isNode(node)) {
-        return undefined;
-    }
-    if (node.type === "Identifier" && typeof node.name === "string") {
-        return node.name;
-    }
-    if ((node.type === "StringLiteral" || node.type === "NumericLiteral" || node.type === "Literal") && node.value !== undefined) {
-        return String(node.value);
-    }
-    return undefined;
-}
-function bindingNames(node) {
-    if (!isNode(node)) {
-        return [];
-    }
-    if (node.type === "Identifier") {
-        return typeof node.name === "string" ? [node.name] : [];
-    }
-    if (node.type === "ObjectPattern") {
-        return asArray(node.properties).flatMap((property) => {
-            if (!isNode(property)) {
-                return [];
-            }
-            if (property.type === "RestElement") {
-                return bindingNames(property.argument);
-            }
-            return bindingNames(property.value);
-        });
-    }
-    if (node.type === "ArrayPattern") {
-        return asArray(node.elements).flatMap((element) => bindingNames(element));
-    }
-    if (node.type === "RestElement" || node.type === "AssignmentPattern") {
-        return bindingNames(node.left ?? node.argument);
-    }
-    return [];
-}
-function addExport(exportsList, exportedAs, node, identifierNode, options = {}) {
-    const candidate = {
-        name: options.name ?? exportedAs,
-        exportedAs,
-        isDefault: options.isDefault ?? false,
-        isReExport: options.isReExport ?? false,
-        isWildcard: options.isWildcard ?? false,
-        isTypeOnly: options.isTypeOnly ?? false,
-    };
-    if (options.members)
-        candidate.members = options.members;
-    // Use precise identifier node location if provided, otherwise default to full node
-    const location = positionRange(identifierNode) ?? positionRange(node);
-    if (location) {
-        candidate.location = location;
-    }
-    if (!exportsList.some((item) => item.exportedAs === candidate.exportedAs && item.name === candidate.name)) {
-        exportsList.push(candidate);
-    }
-}
-function addEdge(edges, sourceFile, rawSpecifier, kind, node, importedNames = [], isTypeOnly = false, dynamicExpression) {
-    const edge = {
-        source: sourceFile,
-        rawSpecifier,
-        kind,
-        importedNames,
-        resolution: "unknown",
-        isTypeOnly,
-        dynamicExpression,
-    };
-    const location = positionRange(node);
-    if (location) {
-        edge.location = location;
-    }
-    edges.push(edge);
-}
-function importSpecifierNames(specifiers) {
-    const names = [];
-    for (const specifier of specifiers) {
-        if (!isNode(specifier)) {
-            continue;
-        }
-        if (specifier.type === "ImportDefaultSpecifier") {
-            names.push("default");
-        }
-        else if (specifier.type === "ImportNamespaceSpecifier") {
-            names.push("*");
-        }
-        else if (specifier.type === "ImportSpecifier") {
-            names.push(propertyKeyName(specifier.imported) ?? "*");
-        }
-    }
-    return names;
-}
-function exportSpecifierNames(specifiers, useLocal = false) {
-    const names = [];
-    for (const specifier of specifiers) {
-        if (isNode(specifier)) {
-            const nameNode = useLocal ? (specifier.local || specifier.exported) : specifier.exported;
-            names.push(propertyKeyName(nameNode) ?? "*");
-        }
-    }
-    return names;
-}
-function isRequireCall(node) {
-    return node.type === "CallExpression" && nodeIdentifierName(node.callee) === "require";
-}
-function isDynamicImportCall(node) {
-    return (node.type === "ImportExpression" ||
-        (node.type === "CallExpression" && isNode(node.callee) && node.callee.type === "Import"));
-}
-function dynamicArgument(node) {
-    if (node.type === "ImportExpression") {
-        return node.source;
-    }
-    return asArray(node.arguments)[0];
-}
-function templateParts(node) {
-    if (!isNode(node) || node.type !== "TemplateLiteral") {
-        return undefined;
-    }
-    const expressions = asArray(node.expressions);
-    const quasis = asArray(node.quasis);
-    if (expressions.length === 0 || quasis.length < 2) {
-        return undefined;
-    }
-    const first = quasis[0];
-    const last = quasis[quasis.length - 1];
-    const firstValue = isNode(first) && isNode(first.value) && typeof first.value.cooked === "string" ? first.value.cooked : "";
-    const lastValue = isNode(last) && isNode(last.value) && typeof last.value.cooked === "string" ? last.value.cooked : "";
-    return { prefix: firstValue, suffix: lastValue };
-}
-function walk(node, visitor, stack = []) {
-    if (Array.isArray(node)) {
-        for (const item of node) {
-            walk(item, visitor, stack);
-        }
-        return;
-    }
-    if (!isNode(node)) {
-        return;
-    }
-    const currentStack = [...stack, node];
-    visitor(node, stack);
-    // If this is a File node, we only want to walk into the program
-    if (node.type === "File" && node.program) {
-        walk(node.program, visitor, currentStack);
-        return;
-    }
-    for (const [key, value] of Object.entries(node)) {
-        if (key === "loc" ||
-            key === "start" ||
-            key === "end" ||
-            key === "tokens" ||
-            key === "comments" ||
-            key === "errors" ||
-            key === "extra") {
-            continue;
-        }
-        if (Array.isArray(value) || isNode(value)) {
-            walk(value, visitor, currentStack);
-        }
-    }
-}
-function extractAstModule(sourceText, file, ast, parserErrors) {
-    const exportsList = [];
-    const edges = [];
-    const parseDiagnostics = parserErrors.map((error) => {
-        const candidate = error;
-        const diagnostic = {
-            message: typeof candidate.message === "string" ? candidate.message : "Recoverable parser error",
-            file,
-            recovered: true,
-        };
-        if (typeof candidate.loc?.line === "number" && typeof candidate.loc?.column === "number") {
-            diagnostic.location = {
-                start: { line: candidate.loc.line, column: candidate.loc.column },
-                end: { line: candidate.loc.line, column: candidate.loc.column + 1 },
-            };
-        }
-        return diagnostic;
-    });
-    let hasUnknownDynamicBoundary = false;
-    let hasUnresolvedCommonJsExports = false;
-    const scannedDirectories = [];
-    const dynamicImportCandidates = [];
-    const localSymbolDeps = new Map();
-    const localTypeMap = {};
-    const localReferences = new Set();
-    const getActiveDeclaration = (s) => {
-        for (let i = s.length - 1; i >= 0; i--) {
-            const n = s[i];
-            if (!n)
-                continue;
-            if (n.type === "FunctionDeclaration" || n.type === "ClassDeclaration" || n.type === "TSInterfaceDeclaration" || n.type === "TSTypeAliasDeclaration" || n.type === "TSEnumDeclaration") {
-                return nodeIdentifierName(n.id);
-            }
-            if (n.type === "VariableDeclarator") {
-                const names = bindingNames(n.id);
-                return names[0];
-            }
-        }
-        return undefined;
-    };
-    walk(ast, (node, stack) => {
-        // Compatibility: Map Yuku attached comments to leadingComments/trailingComments
-        const yukuNode = node;
-        // Track local variable types from annotations
-        if (node.type === "VariableDeclarator") {
-            const id = yukuNode.id;
-            if (id && id.type === "Identifier") {
-                const ta = id.typeAnnotation;
-                if (ta && ta.type === "TSTypeAnnotation" && ta.typeAnnotation?.type === "TSTypeReference") {
-                    const typeName = nodeIdentifierName(ta.typeAnnotation.typeName);
-                    if (typeName) {
-                        localTypeMap[id.name] = typeName;
-                    }
-                }
-            }
-        }
-        if (Array.isArray(yukuNode.comments)) {
-            yukuNode.leadingComments = yukuNode.comments
-                .filter((c) => c.position === "before")
-                .map((c) => ({
-                type: c.type === "Line" ? "CommentLine" : "CommentBlock",
-                value: c.value,
-            }));
-            yukuNode.trailingComments = yukuNode.comments
-                .filter((c) => c.position === "after")
-                .map((c) => ({
-                type: c.type === "Line" ? "CommentLine" : "CommentBlock",
-                value: c.value,
-            }));
-        }
-        // Fix 3: Track local references
-        if (node.type === "Identifier") {
-            const parent = stack[stack.length - 1];
-            if (parent) {
-                let isRef = true;
-                // Definitions/Names of exports are NOT references to other symbols
-                if (parent.type === "ExportSpecifier" && (parent.local === node || parent.exported === node))
-                    isRef = false;
-                if (parent.type === "ExportDefaultDeclaration" && parent.declaration === node)
-                    isRef = false;
-                if (parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier")
-                    isRef = false;
-                // Property keys are not references to top-level symbols
-                if (parent.type === "MemberExpression" && parent.property === node && !parent.computed)
-                    isRef = false;
-                if (parent.type === "ObjectProperty" && parent.key === node && !parent.computed)
-                    isRef = false;
-                if (parent.type === "TSPropertySignature" && parent.key === node)
-                    isRef = false;
-                if (parent.type === "TSMethodSignature" && parent.key === node)
-                    isRef = false;
-                // Definitions are NOT references to the symbol itself
-                if ((parent.type === "FunctionDeclaration" || parent.type === "ClassDeclaration" || parent.type === "TSInterfaceDeclaration" || parent.type === "TSTypeAliasDeclaration" || parent.type === "TSEnumDeclaration" || parent.type === "VariableDeclarator") && parent.id === node)
-                    isRef = false;
-                if (isRef) {
-                    const active = getActiveDeclaration(stack);
-                    if (active) {
-                        if (active !== node.name) {
-                            if (!localSymbolDeps.has(active))
-                                localSymbolDeps.set(active, new Set());
-                            localSymbolDeps.get(active).add(node.name);
-                        }
-                    }
-                    else {
-                        // Top-level usage (code not inside a function/class)
-                        // Use empty string as the key for top-level references
-                        if (!localSymbolDeps.has(""))
-                            localSymbolDeps.set("", new Set());
-                        localSymbolDeps.get("").add(node.name);
-                    }
-                    localReferences.add(node.name);
-                }
-            }
-        }
-        if (node.type === "ImportDeclaration") {
-            const specifier = nodeStringValue(node.source);
-            if (specifier) {
-                const isTypeOnly = node.importKind === "type";
-                addEdge(edges, file, specifier, "import", node, importSpecifierNames(asArray(node.specifiers)), isTypeOnly);
-            }
-            return;
-        }
-        if (node.type === "ExportNamedDeclaration") {
-            const specifier = nodeStringValue(node.source);
-            if (specifier) {
-                const isTypeOnly = node.exportKind === "type";
-                const specifiers = asArray(node.specifiers);
-                const localNames = [];
-                for (const spec of specifiers) {
-                    if (isNode(spec) && spec.type === "ExportSpecifier") {
-                        const localName = propertyKeyName(spec.local || spec.exported) ?? "*";
-                        const exportedName = propertyKeyName(spec.exported) ?? "*";
-                        localNames.push(localName);
-                        addExport(exportsList, exportedName, node, spec.exported, {
-                            name: localName,
-                            isReExport: true,
-                            isTypeOnly: isTypeOnly
-                        });
-                    }
-                }
-                addEdge(edges, file, specifier, "export-from", node, localNames, isTypeOnly);
-            }
-            else if (isNode(node.declaration)) {
-                const declaration = node.declaration;
-                if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration" || declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || declaration.type === "TSEnumDeclaration") && nodeIdentifierName(declaration.id)) {
-                    // TSInterfaceDeclaration and TSTypeAliasDeclaration are pure type constructs erased
-                    // at compile time.
-                    // TSEnumDeclaration: 'const enum' is erased/inlined, but regular 'enum' emits a
-                    // runtime IIFE object. We only mark it as type-only if it's a 'const enum'.
-                    const isType = declaration.type === "TSInterfaceDeclaration" ||
-                        declaration.type === "TSTypeAliasDeclaration" ||
-                        (declaration.type === "TSEnumDeclaration" && declaration.const === true) ||
-                        node.exportKind === "type";
-                    // Member Extraction for Enums, Interfaces, and Classes
-                    const members = [];
-                    const decl = declaration;
-                    if (decl.type === "TSEnumDeclaration") {
-                        const enumMembers = decl.members || decl.body?.members || [];
-                        for (const member of asArray(enumMembers)) {
-                            const m = member;
-                            const name = nodeIdentifierName(m.id) || nodeStringValue(m.id);
-                            if (name)
-                                members.push({ name, location: positionRange(m) });
-                        }
-                    }
-                    else if (decl.type === "TSInterfaceDeclaration") {
-                        const body = decl.body?.body || [];
-                        for (const member of asArray(body)) {
-                            const m = member;
-                            const name = nodeIdentifierName(m.key) || nodeStringValue(m.key);
-                            if (name)
-                                members.push({ name, location: positionRange(m) });
-                        }
-                    }
-                    else if (decl.type === "ClassDeclaration") {
-                        const body = decl.body?.body || [];
-                        for (const member of asArray(body)) {
-                            const m = member;
-                            if (m.type === "MethodDefinition" || m.type === "PropertyDefinition" || m.type === "ClassProperty" || m.type === "ClassMethod") {
-                                const name = nodeIdentifierName(m.key) || nodeStringValue(m.key);
-                                if (name && name !== "constructor")
-                                    members.push({ name, location: positionRange(m) });
-                            }
-                        }
-                    }
-                    addExport(exportsList, nodeIdentifierName(decl.id) ?? "unknown", node, decl.id, {
-                        isTypeOnly: isType,
-                        members: members.length > 0 ? members : undefined
-                    });
-                }
-                else if (declaration.type === "VariableDeclaration") {
-                    for (const declarator of asArray(declaration.declarations)) {
-                        if (isNode(declarator)) {
-                            for (const name of bindingNames(declarator.id)) {
-                                addExport(exportsList, name, node, declarator.id, { isTypeOnly: node.exportKind === "type" });
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                for (const exportedName of exportSpecifierNames(asArray(node.specifiers))) {
-                    addExport(exportsList, exportedName, node, undefined, { isTypeOnly: node.exportKind === "type" });
-                }
-            }
-            return;
-        }
-        if (node.type === "ExportDefaultDeclaration") {
-            addExport(exportsList, "default", node, undefined, { name: "default", isDefault: true, isTypeOnly: node.exportKind === "type" });
-            return;
-        }
-        if (node.type === "ExportAllDeclaration") {
-            const specifier = nodeStringValue(node.source);
-            if (specifier) {
-                addEdge(edges, file, specifier, "export-all", node, ["*"], node.exportKind === "type");
-                addExport(exportsList, "*", node, undefined, { name: "*", isReExport: true, isWildcard: true, isTypeOnly: node.exportKind === "type" });
-            }
-            return;
-        }
-        if (isRequireCall(node)) {
-            const specifier = nodeStringValue(asArray(node.arguments)[0]);
-            if (specifier) {
-                addEdge(edges, file, specifier, "require", node, ["*"]);
-            }
-            else {
-                hasUnknownDynamicBoundary = true;
-            }
-            return;
-        }
-        if (isDynamicImportCall(node)) {
-            const argument = dynamicArgument(node);
-            let literal = nodeStringValue(argument);
-            // Handle pathToFileURL(path.join(...)).href
-            if (!literal && isNode(argument) && argument.type === "MemberExpression" && nodeIdentifierName(argument.property) === "href") {
-                const obj = argument.object;
-                if (isNode(obj) && obj.type === "CallExpression" && nodeIdentifierName(obj.callee) === "pathToFileURL") {
-                    literal = nodeStringValue(asArray(obj.arguments)[0]);
-                    // Even if it's still not a literal, templateParts might handle the inner call
-                }
-            }
-            if (literal) {
-                addEdge(edges, file, literal, "dynamic-literal", node, ["*"]);
-            }
-            else {
-                const parts = templateParts(argument) || (isNode(argument) && argument.type === "CallExpression" && nodeIdentifierName(argument.callee) === "pathToFileURL" ? templateParts(asArray(argument.arguments)[0]) : undefined);
-                if (parts) {
-                    const edge = {
-                        source: file,
-                        rawSpecifier: `${parts.prefix}${"${…}"}${parts.suffix}`,
-                        kind: "dynamic-pattern",
-                        importedNames: ["*"],
-                        resolution: "unknown",
-                        dynamicPattern: {
-                            prefix: parts.prefix,
-                            suffix: parts.suffix,
-                            baseDirectory: "", // Would need proper calculation
-                            candidates: []
-                        }
-                    };
-                    const location = positionRange(node);
-                    if (location)
-                        edge.location = location;
-                    edges.push(edge);
-                }
-                // Even if it's a pattern, we add it to dynamicImportCandidates so Layer 4 
-                // can try to resolve it more precisely if possible.
-                {
-                    hasUnknownDynamicBoundary = true;
-                    const expressionText = sourceText.slice(node.start, node.end);
-                    const location = positionRange(node);
-                    if (location) {
-                        // Find the containing function or block to capture local variables
-                        let contextCode = "";
-                        const scopeNode = [...stack].reverse().find(n => n.type === "FunctionDeclaration" ||
-                            n.type === "FunctionExpression" ||
-                            n.type === "ArrowFunctionExpression" ||
-                            n.type === "ClassMethod" ||
-                            n.type === "ObjectMethod");
-                        // IMPROVEMENT: Capture both the top-level definitions and the specific 
-                        // function body to ensure variables from outer scopes are available 
-                        // AND the import logic is actually executed.
-                        let topLevelCode = "";
-                        const program = stack[0];
-                        if (program && program.type === "File" && program.program) {
-                            const topNodes = asArray(program.program.body);
-                            // Extract top-level declarations (const, let, var, function)
-                            topLevelCode = topNodes
-                                .filter((n) => n.type === "VariableDeclaration" ||
-                                n.type === "FunctionDeclaration" ||
-                                n.type === "ExportNamedDeclaration" ||
-                                n.type === "ExportDefaultDeclaration")
-                                .map((n) => sourceText.slice(n.start, n.end))
-                                .join("\n");
-                        }
-                        let bodyCode = "";
-                        if (scopeNode && isNode(scopeNode.body)) {
-                            const body = scopeNode.body;
-                            const start = body.start;
-                            if (typeof start === "number" && typeof node.start === "number") {
-                                const bStart = (body.type === "BlockStatement" ? start + 1 : start);
-                                const bEnd = body.end - (body.type === "BlockStatement" ? 1 : 0);
-                                bodyCode = sourceText.slice(bStart, bEnd);
-                                // Prepend parameters
-                                const params = scopeNode.params;
-                                if (Array.isArray(params)) {
-                                    const paramNames = params.flatMap(p => bindingNames(p));
-                                    if (paramNames.length > 0) {
-                                        bodyCode = `var ${paramNames.join(', ')};\n${bodyCode}`;
-                                    }
-                                }
-                            }
-                        }
-                        contextCode = `${topLevelCode}\n\n// --- Function Body ---\n${bodyCode || expressionText}`;
-                        dynamicImportCandidates.push({
-                            file,
-                            line: location.start.line,
-                            column: location.start.column,
-                            expression: expressionText,
-                            contextCode: contextCode,
-                        });
-                    }
-                    if (!parts) {
-                        addEdge(edges, file, "<unknown dynamic import>", "unknown-dynamic", node, ["*"], false, expressionText);
-                    }
-                }
-            }
-            return;
-        }
-        // Detect readdir / readdirSync / fs.promises.readdir with smarter path resolution
-        if (node.type === "CallExpression") {
-            const callee = node.callee;
-            // Match: readdir(...), readdirSync(...), fs.readdir(...), fs.readdirSync(...),
-            //        fs.promises.readdir(...), promises.readdir(...)
-            const isReaddir = (callee.type === "Identifier" && (callee.name === "readdir" || callee.name === "readdirSync")) ||
-                (callee.type === "MemberExpression" && (callee.property?.name === "readdir" || callee.property?.name === "readdirSync")) ||
-                // fs.promises.readdir
-                (callee.type === "MemberExpression" &&
-                    isNode(callee.object) &&
-                    callee.object.type === "MemberExpression" &&
-                    (callee.property?.name === "readdir" || callee.property?.name === "readdirSync"));
-            if (isReaddir) {
-                const arg = asArray(node.arguments)[0];
-                let dir = nodeStringValue(arg);
-                // Handle path.join(__dirname, 'plugins') or path.resolve(..., 'dir') or similar
-                if (!dir && arg?.type === "CallExpression") {
-                    const methodName = arg.callee?.property?.name ?? arg.callee?.name;
-                    if (methodName === "join" || methodName === "resolve") {
-                        const joinArgs = asArray(arg.arguments);
-                        // Collect all string literal segments (skip __dirname / __filename / variables)
-                        const stringParts = joinArgs
-                            .map((a) => nodeStringValue(a))
-                            .filter((s) => s !== undefined && !s.startsWith("/"));
-                        if (stringParts.length > 0) {
-                            // Use the relative sub-path formed by the string literals
-                            dir = stringParts.join("/");
-                        }
-                    }
-                }
-                if (dir) {
-                    scannedDirectories.push(dir);
-                }
-                else {
-                    // If we can't resolve the directory but it's a variable,
-                    // we mark it as a potential dynamic scan boundary.
-                    hasUnknownDynamicBoundary = true;
-                }
-            }
-        }
-        if (node.type === "AssignmentExpression" && isNode(node.left) && node.left.type === "MemberExpression") {
-            const objectName = nodeIdentifierName(node.left.object);
-            const property = node.left.computed ? propertyKeyName(node.left.property) : nodeIdentifierName(node.left.property);
-            if (objectName === "exports" && property) {
-                addExport(exportsList, property, node);
-            }
-            else if (objectName === "exports") {
-                hasUnresolvedCommonJsExports = true;
-            }
-            else if (objectName === "module" && property === "exports") {
-                hasUnresolvedCommonJsExports = true;
-            }
-            else if (isNode(node.left.object) && node.left.object.type === "MemberExpression") {
-                const moduleName = nodeIdentifierName(node.left.object.object);
-                const moduleProperty = nodeIdentifierName(node.left.object.property);
-                if (moduleName === "module" && moduleProperty === "exports" && property) {
-                    addExport(exportsList, property, node);
-                }
-            }
-            else if (node.left.name === "exports") {
-                hasUnresolvedCommonJsExports = true;
-            }
-        }
-    });
-    // Attach local references to exports
-    for (const exp of exportsList) {
-        const deps = localSymbolDeps.get(exp.name);
-        if (deps) {
-            exp.localReferences = Array.from(deps);
-        }
-    }
-    const localSymbolMap = {};
-    for (const [name, deps] of localSymbolDeps.entries()) {
-        localSymbolMap[name] = Array.from(deps);
-    }
-    const module = {
-        id: file,
-        relativePath: file,
-        parseStatus: parserErrors.length > 0 ? "recovered" : "parsed",
-        parseDiagnostics,
-        ast,
-        sourceText,
-        exports: exportsList,
-        edges,
-        hasUnknownDynamicBoundary,
-        hasParseError: parserErrors.length > 0,
-        hasUnresolvedCommonJsExports,
-        scannedDirectories,
-        dynamicImportCandidates,
-        localSymbolMap,
-        localTypeMap,
-        localReferences: Array.from(localReferences),
-    };
-    return module;
-}
-function fallbackExports(sourceText, file) {
-    const found = [];
-    const regex = /\bexport\s+(?:async\s+)?(?:function|class|const|let|var)\s+([A-Za-z_$][\w$]*)|\bexport\s+default\b|\bexport\s*\{([^}]+)\}/g;
-    for (const match of sourceText.matchAll(regex)) {
-        const location = locationAtOffset(sourceText, match.index ?? 0);
-        if (match[1]) {
-            found.push({ name: match[1], exportedAs: match[1], isDefault: false, isReExport: false, isWildcard: false, location });
-        }
-        else if (match[0].includes("export default")) {
-            found.push({ name: "default", exportedAs: "default", isDefault: true, isReExport: false, isWildcard: false, location });
-        }
-        else if (match[2]) {
-            for (const part of match[2].split(",")) {
-                const exportedAs = part.trim().split(/\s+as\s+/i).at(-1)?.trim();
-                if (exportedAs) {
-                    found.push({ name: exportedAs, exportedAs, isDefault: exportedAs === "default", isReExport: false, isWildcard: false, location });
-                }
-            }
-        }
-    }
-    return found;
-}
-function fallbackEdges(sourceText, file) {
-    const edges = [];
-    // 1. Detailed Import Pattern: import { a, b as c } from '...'
-    const detailedImportRegex = /\bimport\s+(?:\{([^}]+)\}|([a-zA-Z_$][\w$]*)(?:\s*,\s*\{([^}]+)\})?|\*\s+as\s+([a-zA-Z_$][\w$]*))\s+from\s+["']([^"'\n]+)["']/g;
-    for (const match of sourceText.matchAll(detailedImportRegex)) {
-        const namedImports = match[1] || match[3];
-        const defaultImport = match[2];
-        const namespaceImport = match[4];
-        const specifier = match[5];
-        if (specifier) {
-            const names = [];
-            if (namespaceImport)
-                names.push("*");
-            if (defaultImport)
-                names.push("default");
-            if (namedImports) {
-                namedImports.split(",").forEach(n => {
-                    const parts = n.trim().split(/\s+as\s+/i);
-                    const imported = parts[0]?.trim();
-                    if (imported)
-                        names.push(imported);
-                });
-            }
-            edges.push({
-                source: file,
-                rawSpecifier: specifier,
-                kind: "import",
-                importedNames: names.length > 0 ? names : ["*"],
-                resolution: "unknown",
-                location: locationAtOffset(sourceText, match.index ?? 0),
-            });
-        }
-    }
-    // 2. Simple/Other Patterns
-    const patterns = [
-        { regex: /\bimport\s+["']([^"'\n]+)["']/g, kind: "import" }, // side-effect import
-        { regex: /\bexport\s+(?:\*|\{[^}]*\})\s+from\s+["']([^"'\n]+)["']/g, kind: "export-from" },
-        { regex: /\brequire\s*\(\s*["']([^"'\n]+)["']\s*\)/g, kind: "require" },
-        { regex: /\bimport\s*\(\s*["']([^"'\n]+)["']\s*\)/g, kind: "dynamic-literal" },
-    ];
-    for (const { regex, kind } of patterns) {
-        for (const match of sourceText.matchAll(regex)) {
-            const specifier = match[1];
-            if (specifier && !edges.some(e => e.rawSpecifier === specifier && e.location?.start.line === locationAtOffset(sourceText, match.index ?? 0).start.line)) {
-                edges.push({
-                    source: file,
-                    rawSpecifier: specifier,
-                    kind,
-                    importedNames: ["*"],
-                    resolution: "unknown",
-                    location: locationAtOffset(sourceText, match.index ?? 0),
-                });
-            }
-        }
-    }
-    for (const match of sourceText.matchAll(/\bimport\s*\(\s*`([^`]*)`\s*\)/g)) {
-        const raw = match[1] ?? "";
-        const expressionIndex = raw.indexOf("${");
-        const closeIndex = raw.lastIndexOf("}");
-        if (expressionIndex >= 0 && closeIndex > expressionIndex) {
-            edges.push({
-                source: file,
-                rawSpecifier: `${raw.slice(0, expressionIndex)}${"${…}"}${raw.slice(closeIndex + 1)}`,
-                kind: "dynamic-pattern",
-                importedNames: ["*"],
-                resolution: "unknown",
-                location: locationAtOffset(sourceText, match.index ?? 0),
-            });
-        }
-    }
-    return edges;
-}
-function fallbackModule(sourceText, file, reason) {
-    const originalMessage = reason instanceof Error ? reason.message : "Parser could not recover this file";
-    return {
-        id: file,
-        relativePath: file,
-        parseStatus: "fallback",
-        parseDiagnostics: [
-            {
-                message: `${originalMessage} (Module parse failed, using regex fallback)`,
-                file,
-                recovered: false,
-            },
-        ],
-        sourceText,
-        exports: fallbackExports(sourceText, file),
-        edges: fallbackEdges(sourceText, file),
-        hasUnknownDynamicBoundary: false, // Parse error is not necessarily a dynamic boundary
-        hasParseError: true,
-        hasUnresolvedCommonJsExports: false,
-        scannedDirectories: [],
-        dynamicImportCandidates: [],
-    };
-}
-export function parseModule(sourceText, file) {
-    try {
-        // RESILIENCE FIX: Handle literal \n sequences often found in generated tests or copy-pastes
-        // This ensures the parser doesn't choke on "Invalid Unicode escape sequence"
-        if (sourceText.includes('\\n')) {
-            sourceText = sourceText.replace(/\\n/g, '\n');
-        }
-        // Use yuku-parser instead of @babel/parser.
-        // yuku-parser infers the best language variant from the file extension;
-        // fall back to tsx (covers JS/TS/JSX/TSX) when the extension is unknown.
-        const lang = langFromPath(file) ?? "tsx";
-        const sourceType = sourceTypeFromPath(file) ?? "module";
-        setYukuSource(sourceText);
-        const result = yukuParse(sourceText, { lang, sourceType, semanticErrors: false, attachComments: true });
-        // Map yuku-parser diagnostics to the shape extractAstModule expects
-        const parserErrors = result.diagnostics
-            .filter((d) => d.severity === "error")
-            .map((d) => ({
-            message: d.message,
-            loc: d.start != null ? (() => {
-                const pos = offsetToPosition(d.start);
-                return { line: pos.line, column: pos.column };
-            })() : undefined,
-        }));
-        // Yuku returns errors in diagnostics. If there are errors, trigger fallback for tests that expect "Parse failed"
-        if (result.diagnostics?.some(d => d.severity === 'error')) {
-            const firstError = result.diagnostics[0]?.message ?? "Unknown parse error";
-            return fallbackModule(sourceText, file, new Error("Parse failed: " + firstError));
-        }
-        // Wrap in a "File" node to match what Layer 5/7 might expect from Babel
-        const ast = {
-            type: "File",
-            program: result.program,
-            comments: result.comments
-        };
-        return extractAstModule(sourceText, file, ast, []);
-    }
-    catch (error) {
-        return fallbackModule(sourceText, file, error);
-    }
-}
-export function getNodeRange(node) {
-    return isNode(node) ? positionRange(node) : undefined;
-}
-export function getNodeType(node) {
-    return isNode(node) ? node.type : undefined;
-}
-export function getNodeProperty(node, property) {
-    return isNode(node) ? node[property] : undefined;
-}
-export function getStringLiteral(node) {
-    return nodeStringValue(node);
-}
-export function getIdentifier(node) {
-    return nodeIdentifierName(node);
-}
-export function isAstNode(node) {
-    return isNode(node);
-}
-export function walkAst(node, visitor) {
-    walk(node, visitor);
-}
-//# sourceMappingURL=parser.js.map