phantom-build 0.1.0

package/dist/cli.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { analyzeModule } from './analyzer.js';
+// ── Argument parsing ─────────────────────────────────────────────────
+function printUsage() {
+    console.log(`
+Usage: phantom analyze <file> [options]
+
+Analyze a single file and print segment classification details.
+
+Options:
+  --threshold <number>   Confidence threshold for extraction (default: 0.8)
+  --help, -h             Show this help message
+`.trim());
+}
+function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        printUsage();
+        process.exit(args.length === 0 ? 1 : 0);
+    }
+    const command = args[0];
+    if (command !== 'analyze') {
+        console.error(`Unknown command: ${command}`);
+        printUsage();
+        process.exit(1);
+    }
+    const filePath = args[1];
+    if (!filePath) {
+        console.error('Error: No file specified');
+        printUsage();
+        process.exit(1);
+    }
+    // Parse --threshold flag
+    let threshold = 0.8;
+    const thresholdIdx = args.indexOf('--threshold');
+    if (thresholdIdx !== -1) {
+        const val = parseFloat(args[thresholdIdx + 1]);
+        if (isNaN(val) || val < 0 || val > 1) {
+            console.error('Error: --threshold must be a number between 0 and 1');
+            process.exit(1);
+        }
+        threshold = val;
+    }
+    // Read and analyze the file
+    const absolutePath = resolve(filePath);
+    let code;
+    try {
+        code = readFileSync(absolutePath, 'utf-8');
+    }
+    catch {
+        console.error(`Error: Cannot read file "${absolutePath}"`);
+        process.exit(1);
+    }
+    const result = analyzeModule(code, absolutePath, { confidenceThreshold: threshold });
+    // ── Output ───────────────────────────────────────────────────────
+    console.log(`\nPhantom Analysis: ${filePath}`);
+    console.log('═'.repeat(60));
+    if (result.segments.length === 0) {
+        console.log('No classifiable segments found.');
+        return;
+    }
+    // Segment table
+    console.log(`\n  ${'Name'.padEnd(30)} ${'Class'.padEnd(20)} ${'Conf'.padEnd(6)} Extracted?`);
+    console.log(`  ${'─'.repeat(30)} ${'─'.repeat(20)} ${'─'.repeat(6)} ${'─'.repeat(10)}`);
+    for (const seg of result.segments) {
+        const extracted = result.chunkModules?.some((m) => m.id === seg.id) ? '✓ yes' : '  no';
+        console.log(`  ${seg.name.padEnd(30)} ${seg.classification.padEnd(20)} ${seg.confidence.toFixed(2).padStart(5)}  ${extracted}`);
+        if (seg.reasons.length > 0) {
+            for (const reason of seg.reasons) {
+                console.log(`    → ${reason}`);
+            }
+        }
+    }
+    // Summary
+    console.log('');
+    console.log(`  Segments: ${result.segments.length}`);
+    console.log(`  Threshold: ${threshold}`);
+    if (result.chunkModules && result.chunkModules.length > 0) {
+        console.log(`  Chunks extracted: ${result.chunkModules.length}`);
+        for (const mod of result.chunkModules) {
+            const sizeKb = (Buffer.byteLength(mod.code, 'utf-8') / 1024).toFixed(1);
+            console.log(`    ${mod.id} (${sizeKb} KB)`);
+        }
+    }
+    else {
+        console.log('  Chunks extracted: 0');
+    }
+    // Lazy component candidates
+    if (result.lazyCandidates && result.lazyCandidates.length > 0) {
+        console.log(`\n  Lazy Components:`);
+        console.log(`  ${'Name'.padEnd(25)} ${'Strategy'.padEnd(12)} Group`);
+        console.log(`  ${'─'.repeat(25)} ${'─'.repeat(12)} ${'─'.repeat(15)}`);
+        for (const lc of result.lazyCandidates) {
+            console.log(`  ${lc.localName.padEnd(25)} ${lc.prefetch.padEnd(12)} ${lc.suspenseGroup ?? '(solo)'}`);
+            console.log(`    → ${lc.reason}`);
+        }
+    }
+    if (result.lazyKeptStatic && result.lazyKeptStatic.length > 0) {
+        console.log(`\n  Kept Static:`);
+        for (const ks of result.lazyKeptStatic) {
+            console.log(`    ${ks.localName.padEnd(25)} → ${ks.reason}`);
+        }
+    }
+    console.log('');
+}
+main();
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/extract/chunk-module.d.ts

@@ -0,0 +1,20 @@
+import type { ClassifiedSegment, ImportInfo, SourceMapLike } from '../types.js';
+import type { ExtractableNode } from './client-stub.js';
+/**
+ * Generate a lazy-loaded chunk module that exports the extracted function.
+ *
+ * Output shape:
+ *
+ *   import { someUtil } from './utils';
+ *
+ *   export function seg_abc123(e) {
+ *     e.preventDefault();
+ *     const form = e.target;
+ *     // ...handler logic
+ *   }
+ */
+export declare function generateChunkModule(segment: ClassifiedSegment, astNode: ExtractableNode, imports: ImportInfo[], capturedParams: string[], sourceFilePath: string, sourceCode: string): {
+    code: string;
+    map: SourceMapLike;
+};
+//# sourceMappingURL=chunk-module.d.ts.map

package/dist/extract/chunk-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-module.d.ts","sourceRoot":"","sources":["../../src/extract/chunk-module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAyFxD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,UAAU,EAAE,EACrB,cAAc,EAAE,MAAM,EAAE,EACxB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,aAAa,CAAA;CAAE,CA0FtC"}

package/dist/extract/chunk-module.js

@@ -0,0 +1,163 @@
+import { print } from 'esrap';
+import tsx from 'esrap/languages/tsx';
+// ── TypeScript stripping ────────────────────────────────────────────────
+/**
+ * TS wrapper node types that should be unwrapped to their inner expression.
+ * These nodes exist in OXC's AST when parsing TypeScript but have no JS equivalent.
+ */
+const TS_WRAPPER_TYPES = new Set([
+    'TSAsExpression', // `x as Type`
+    'TSSatisfiesExpression', // `x satisfies Type`
+    'TSNonNullExpression', // `x!`
+    'TSTypeAssertion', // `<Type>x`
+    'TSInstantiationExpression', // `fn<Type>`
+]);
+/**
+ * Properties that carry TypeScript type information and should be deleted.
+ */
+const TS_ANNOTATION_PROPS = ['typeAnnotation', 'returnType', 'typeParameters', 'typeArguments'];
+/**
+ * Recursively strip TypeScript-specific nodes from a cloned ESTree AST.
+ *
+ * This ensures chunk modules are valid JavaScript even when the source
+ * contained TypeScript annotations (e.g., `e.target as HTMLFormElement`).
+ *
+ * Mutates the tree in place and returns it.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function stripTypeAnnotations(node) {
+    if (node == null || typeof node !== 'object')
+        return node;
+    // Handle arrays (e.g., body[], params[])
+    if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+            node[i] = stripTypeAnnotations(node[i]);
+        }
+        return node;
+    }
+    // Skip non-AST objects (Literal values, etc.)
+    if (!node.type)
+        return node;
+    // Unwrap TS wrapper nodes to their inner expression
+    if (TS_WRAPPER_TYPES.has(node.type)) {
+        return stripTypeAnnotations(node.expression);
+    }
+    // Delete TS annotation properties
+    for (const prop of TS_ANNOTATION_PROPS) {
+        if (prop in node) {
+            delete node[prop];
+        }
+    }
+    // Strip TS-only statement types entirely (type aliases, interfaces, enums, etc.)
+    // These shouldn't appear in function bodies, but guard against it
+    if (node.type.startsWith('TS') && node.type !== 'TSModuleBlock') {
+        return node;
+    }
+    // Recurse into all properties
+    for (const key of Object.keys(node)) {
+        if (key === 'type' || key === 'start' || key === 'end')
+            continue;
+        const val = node[key];
+        if (val && typeof val === 'object') {
+            node[key] = stripTypeAnnotations(val);
+        }
+    }
+    return node;
+}
+// ── Chunk module generation ─────────────────────────────────────────────
+/**
+ * Generate a lazy-loaded chunk module that exports the extracted function.
+ *
+ * Output shape:
+ *
+ *   import { someUtil } from './utils';
+ *
+ *   export function seg_abc123(e) {
+ *     e.preventDefault();
+ *     const form = e.target;
+ *     // ...handler logic
+ *   }
+ */
+export function generateChunkModule(segment, astNode, imports, capturedParams, sourceFilePath, sourceCode) {
+    const body = [];
+    // 1. Import declarations
+    for (const imp of imports) {
+        const specifiers = imp.specifiers.map((spec) => {
+            if (spec.kind === 'default') {
+                return {
+                    type: 'ImportDefaultSpecifier',
+                    local: { type: 'Identifier', name: spec.local },
+                };
+            }
+            if (spec.kind === 'namespace') {
+                return {
+                    type: 'ImportNamespaceSpecifier',
+                    local: { type: 'Identifier', name: spec.local },
+                };
+            }
+            return {
+                type: 'ImportSpecifier',
+                imported: { type: 'Identifier', name: spec.imported ?? spec.local },
+                local: { type: 'Identifier', name: spec.local },
+            };
+        });
+        const decl = {
+            type: 'ImportDeclaration',
+            specifiers,
+            source: { type: 'Literal', value: imp.source },
+        };
+        body.push(decl);
+    }
+    // 2. Exported function with original params + captured params
+    // Original function params come first, then captured variables from outer scope.
+    // Strip TypeScript annotations so the generated chunk is valid JavaScript.
+    const originalParams = stripTypeAnnotations(structuredClone(astNode.params));
+    const capturedIdentifiers = capturedParams.map((name) => ({
+        type: 'Identifier',
+        name,
+    }));
+    const params = [...originalParams, ...capturedIdentifiers];
+    let fnBody;
+    if (astNode.type === 'ArrowFunctionExpression' && astNode.body.type !== 'BlockStatement') {
+        // Expression body: () => expr  →  { return expr; }
+        fnBody = stripTypeAnnotations({
+            type: 'BlockStatement',
+            body: [{ type: 'ReturnStatement', argument: structuredClone(astNode.body) }],
+        });
+    }
+    else if (astNode.type === 'ArrowFunctionExpression' || astNode.type === 'FunctionExpression') {
+        fnBody = stripTypeAnnotations(structuredClone(astNode.body));
+    }
+    else {
+        fnBody = stripTypeAnnotations(structuredClone(astNode.body));
+    }
+    const funcDecl = {
+        type: 'FunctionDeclaration',
+        id: { type: 'Identifier', name: segment.id },
+        params,
+        body: fnBody,
+        async: astNode.async ?? false,
+        generator: astNode.generator ?? false,
+    };
+    const exportDecl = {
+        type: 'ExportNamedDeclaration',
+        declaration: funcDecl,
+        specifiers: [],
+        source: null,
+        attributes: [],
+    };
+    body.push(exportDecl);
+    // 3. Generate code with esrap
+    const program = {
+        type: 'Program',
+        sourceType: 'module',
+        body,
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- esrap tsx visitors expect TSESTree.Node, our estree is compatible at runtime
+    const result = print(program, tsx(), {
+        sourceMapSource: sourceFilePath,
+        sourceMapContent: sourceCode,
+    });
+    return { code: result.code, map: result.map };
+}
+//# sourceMappingURL=chunk-module.js.map

package/dist/extract/chunk-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-module.js","sourceRoot":"","sources":["../../src/extract/chunk-module.ts"],"names":[],"mappings":"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"}

package/dist/extract/client-stub.d.ts

@@ -0,0 +1,25 @@
+import type { ClassifiedSegment } from '../types.js';
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from 'estree';
+export type ExtractableNode = ArrowFunctionExpression | FunctionExpression | FunctionDeclaration;
+/**
+ * Replace the function body with a __phantom_lazy() call + synchronous prelude.
+ *
+ * Mutates the AST node in place.
+ *
+ * If the original handler calls preventDefault()/stopPropagation() on its
+ * first param, those calls are hoisted into the synchronous stub so they
+ * execute immediately during event dispatch (before the async import).
+ *
+ * Output shapes:
+ *
+ *   Arrow (no prelude):
+ *     (e) => __phantom_lazy('seg_xxx', e, ...captured)
+ *
+ *   Arrow (with prelude):
+ *     (e) => { e.preventDefault(); e.persist?.(); __phantom_lazy('seg_xxx', e, ...captured); }
+ *
+ *   FunctionExpression / FunctionDeclaration (always block body):
+ *     function f(e) { e.preventDefault(); e.persist?.(); __phantom_lazy('seg_xxx', e, ...captured); }
+ */
+export declare function replaceWithStub(astNode: ExtractableNode, segment: ClassifiedSegment, capturedParams: string[]): void;
+//# sourceMappingURL=client-stub.d.ts.map

package/dist/extract/client-stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-stub.d.ts","sourceRoot":"","sources":["../../src/extract/client-stub.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EACV,uBAAuB,EAIvB,mBAAmB,EACnB,kBAAkB,EAMnB,MAAM,QAAQ,CAAC;AAEhB,MAAM,MAAM,eAAe,GACvB,uBAAuB,GACvB,kBAAkB,GAClB,mBAAmB,CAAC;AAgIxB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,iBAAiB,EAC1B,cAAc,EAAE,MAAM,EAAE,GACvB,IAAI,CAmFN"}

package/dist/extract/client-stub.js

@@ -0,0 +1,233 @@
+// ── Synchronous prelude detection ───────────────────────────────────────
+/**
+ * Event methods that must run synchronously during event dispatch.
+ * If the handler calls these on its first parameter, the stub must
+ * call them BEFORE the async __phantom_lazy() invocation.
+ */
+const SYNC_EVENT_METHODS = new Set([
+    'preventDefault',
+    'stopPropagation',
+    'stopImmediatePropagation',
+]);
+/**
+ * Detect synchronous event method calls in the handler body.
+ *
+ * Walks the AST looking for `e.preventDefault()`, `e.stopPropagation()`, etc.
+ * where `e` is the first parameter of the function.
+ *
+ * Returns deduplicated list of method names that need to be hoisted.
+ */
+function detectSyncEventCalls(astNode) {
+    const firstParam = astNode.params[0];
+    if (!firstParam)
+        return [];
+    // Extract the param name from Identifier or AssignmentPattern (default value)
+    // e.g., (e) => ... or (e = defaultEvent) => ...
+    // Destructured params ({target}) can't call e.preventDefault() — skip them.
+    let paramName = null;
+    if (firstParam.type === 'Identifier') {
+        paramName = firstParam.name;
+    }
+    else if (firstParam.type === 'AssignmentPattern' && firstParam.left.type === 'Identifier') {
+        paramName = firstParam.left.name;
+    }
+    if (!paramName)
+        return [];
+    const found = new Set();
+    walkNode(astNode.body, (node) => {
+        if (node.type !== 'CallExpression')
+            return;
+        const callee = node.callee;
+        if (callee.type !== 'MemberExpression')
+            return;
+        const member = callee;
+        if (member.object.type !== 'Identifier' || member.object.name !== paramName)
+            return;
+        if (member.property.type !== 'Identifier')
+            return;
+        const methodName = member.property.name;
+        if (SYNC_EVENT_METHODS.has(methodName)) {
+            found.add(methodName);
+        }
+    });
+    return [...found];
+}
+/**
+ * Build AST nodes for the synchronous prelude.
+ *
+ * Generates:
+ *   e.preventDefault();       // only if detected
+ *   e.stopPropagation();      // only if detected
+ *   e.persist?.();            // always when handler has event param
+ */
+function buildPrelude(paramName, syncMethods) {
+    const stmts = [];
+    // Hoist detected sync methods
+    for (const method of syncMethods) {
+        stmts.push({
+            type: 'ExpressionStatement',
+            expression: {
+                type: 'CallExpression',
+                callee: {
+                    type: 'MemberExpression',
+                    object: { type: 'Identifier', name: paramName },
+                    property: { type: 'Identifier', name: method },
+                    computed: false,
+                    optional: false,
+                },
+                arguments: [],
+                optional: false,
+            },
+        });
+    }
+    // Always add e.persist?.() for React <17 SyntheticEvent compat
+    stmts.push({
+        type: 'ExpressionStatement',
+        expression: {
+            type: 'CallExpression',
+            callee: {
+                type: 'MemberExpression',
+                object: { type: 'Identifier', name: paramName },
+                property: { type: 'Identifier', name: 'persist' },
+                computed: false,
+                optional: false,
+            },
+            arguments: [],
+            optional: true, // e.persist?.() — optional chaining
+        },
+    });
+    return stmts;
+}
+// ── Param name extraction ───────────────────────────────────────────────
+/**
+ * Extract parameter names from the original function's params.
+ * Handles simple Identifier params and destructuring patterns (uses rest name or fallback).
+ */
+function extractParamNames(params) {
+    return params.map((p, i) => {
+        if (p.type === 'Identifier')
+            return p.name;
+        // For destructured/rest/default patterns, use the pattern directly
+        // The chunk module gets the original params via structuredClone
+        if (p.type === 'AssignmentPattern' && p.left.type === 'Identifier')
+            return p.left.name;
+        if (p.type === 'RestElement' && p.argument.type === 'Identifier')
+            return p.argument.name;
+        return `__arg${i}`;
+    });
+}
+// ── Stub generation ─────────────────────────────────────────────────────
+/**
+ * Replace the function body with a __phantom_lazy() call + synchronous prelude.
+ *
+ * Mutates the AST node in place.
+ *
+ * If the original handler calls preventDefault()/stopPropagation() on its
+ * first param, those calls are hoisted into the synchronous stub so they
+ * execute immediately during event dispatch (before the async import).
+ *
+ * Output shapes:
+ *
+ *   Arrow (no prelude):
+ *     (e) => __phantom_lazy('seg_xxx', e, ...captured)
+ *
+ *   Arrow (with prelude):
+ *     (e) => { e.preventDefault(); e.persist?.(); __phantom_lazy('seg_xxx', e, ...captured); }
+ *
+ *   FunctionExpression / FunctionDeclaration (always block body):
+ *     function f(e) { e.preventDefault(); e.persist?.(); __phantom_lazy('seg_xxx', e, ...captured); }
+ */
+export function replaceWithStub(astNode, segment, capturedParams) {
+    const originalParamNames = extractParamNames(astNode.params);
+    // Detect sync event calls BEFORE mutating the node
+    const syncMethods = detectSyncEventCalls(astNode);
+    // Build the import factory: () => import('phantom:seg_xxx.chunk.js')
+    // This MUST be a static dynamic import so Rollup/Vite can analyze it
+    // and emit the chunk as a separate file for code-splitting.
+    const importFactory = {
+        type: 'ArrowFunctionExpression',
+        params: [],
+        body: {
+            type: 'ImportExpression',
+            source: { type: 'Literal', value: `phantom:${segment.id}.chunk.js` },
+        }, // ImportExpression is ESTree but not in estree types
+        expression: true,
+        async: false,
+        generator: false,
+    };
+    const lazyCall = {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: '__phantom_lazy' },
+        arguments: [
+            importFactory, // factory is first arg
+            { type: 'Literal', value: segment.id },
+            ...originalParamNames.map((name) => ({ type: 'Identifier', name })),
+            ...capturedParams.map((name) => ({ type: 'Identifier', name })),
+        ],
+        optional: false,
+    };
+    // Build simple Identifier params for the stub (original param names only)
+    const stubParams = originalParamNames.map((name) => ({
+        type: 'Identifier',
+        name,
+    }));
+    // Build synchronous prelude. When the handler has an event parameter,
+    // we always add e.persist?.() for React <17 SyntheticEvent compat,
+    // even if no sync methods (preventDefault, etc.) were detected.
+    const firstParamName = originalParamNames[0];
+    const hasPrelude = !!firstParamName;
+    const preludeStmts = hasPrelude
+        ? buildPrelude(firstParamName, syncMethods)
+        : [];
+    // The lazy call as a statement (event handlers return void)
+    const lazyStmt = {
+        type: 'ExpressionStatement',
+        expression: lazyCall,
+    };
+    if (hasPrelude || astNode.type === 'FunctionExpression' || astNode.type === 'FunctionDeclaration') {
+        // Block body: { prelude...; __phantom_lazy(...); }
+        const blockBody = {
+            type: 'BlockStatement',
+            body: [...preludeStmts, lazyStmt],
+        };
+        astNode.body = blockBody;
+        astNode.params = stubParams;
+        // Fix ESTree `expression` property for arrows converted to block body
+        if (astNode.type === 'ArrowFunctionExpression') {
+            astNode.expression = false;
+        }
+        // Strip TS-specific properties that survive from the original node
+        // (the client code is TSX so esrap handles them, but clean up for correctness)
+        if ('returnType' in astNode)
+            delete astNode.returnType;
+    }
+    else {
+        // ArrowFunctionExpression without prelude: expression body
+        // (e) => __phantom_lazy(...)
+        astNode.body = lazyCall;
+        astNode.expression = true;
+        astNode.params = stubParams;
+        if ('returnType' in astNode)
+            delete astNode.returnType;
+    }
+}
+// ── AST walker ──────────────────────────────────────────────────────────
+function walkNode(node, callback) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const child of node)
+            walkNode(child, callback);
+        return;
+    }
+    const obj = node;
+    if (typeof obj.type !== 'string')
+        return;
+    callback(obj);
+    for (const key of Object.keys(obj)) {
+        if (key === 'type')
+            continue;
+        walkNode(obj[key], callback);
+    }
+}
+//# sourceMappingURL=client-stub.js.map

package/dist/extract/client-stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-stub.js","sourceRoot":"","sources":["../../src/extract/client-stub.ts"],"names":[],"mappings":"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"}

package/dist/extract/import-resolver.d.ts

@@ -0,0 +1,20 @@
+import type { ClassifiedSegment, AnalyzedModule, ImportInfo } from '../types.js';
+export interface ImportResolution {
+    /** Import statements needed in the chunk module */
+    imports: ImportInfo[];
+    /** Captured variables that become function parameters */
+    capturedParams: string[];
+}
+/**
+ * Resolve what the extracted segment needs: imports vs captured variables.
+ *
+ * ClassifiedSegment.dependencies merges fn.captured + fn.imported.
+ * We recover the split by matching back to the FunctionDependency via span,
+ * then cross-reference imported names against AnalyzedModule.imports.
+ *
+ * Relative import paths (./foo, ../bar) are rewritten to absolute paths
+ * so that chunk virtual modules (which have no filesystem location) can
+ * resolve their dependencies correctly.
+ */
+export declare function resolveImports(segment: ClassifiedSegment, analyzed: AnalyzedModule, sourceFilePath: string): ImportResolution;
+//# sourceMappingURL=import-resolver.d.ts.map

package/dist/extract/import-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-resolver.d.ts","sourceRoot":"","sources":["../../src/extract/import-resolver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEjF,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,yDAAyD;IACzD,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,cAAc,EACxB,cAAc,EAAE,MAAM,GACrB,gBAAgB,CAsClB"}