value / 2')
+})
+
+it('handles JSX attribute expressions', () => {
+ const masked = maskImportText(
+ 'const node = import fake
;',
+ true,
+ )
+ expect(masked).toContain('import')
+ expect(masked).not.toContain('fake')
+})
+
+it('masks regex literals following control parentheses', () => {
+ expect(
+ maskImportText(
+ 'if (true) /import "fake"/.test(value); import "real"',
+ false,
+ ),
+ ).not.toContain('fake')
+})
diff --git a/packages/plugin-utils/src/__tests__/import-scanner-boundary.test.ts b/packages/plugin-utils/src/__tests__/import-scanner-boundary.test.ts
new file mode 100644
index 000000000..99ffec472
--- /dev/null
+++ b/packages/plugin-utils/src/__tests__/import-scanner-boundary.test.ts
@@ -0,0 +1,55 @@
+import { expect, it } from 'bun:test'
+
+import { scanImports } from '../import-scanner'
+
+it.each(
+ ['function f() {}', 'class C {}'].flatMap((body) =>
+ [
+ 'const x = 1\n',
+ 'async // marker\n',
+ 'const x = call()\n',
+ 'const x = []\n',
+ ].map((prefix) => ({
+ code: `${prefix}${body} /import("phantom")/.test(x); import("./real");`,
+ })),
+ ),
+)('masks regex after an ASI declaration in $code', ({ code }) => {
+ // Given: valid syntax, checked without evaluating the fixture.
+ new Bun.Transpiler({ loader: 'js' }).transformSync(code)
+ // When: scan through the real lexical boundary.
+ const actual = scanImports(code, false)
+ // Then: regex text adds no phantom dependency.
+ expect(actual).toEqual([{ kind: 'dynamic', specifier: './real' }])
+})
+
+it.each(
+ ['function f() {}', 'class C {}'].flatMap((body) =>
+ [
+ ['const value =\n', ';'],
+ ['const value = (\n', ');'],
+ ['const value = [\n', '];'],
+ ['const value = { field:\n', '};'],
+ ['const value = ok ?\n', ': 0;'],
+ ['call(0,\n', ');'],
+ ['function outer() { return ', '; }'],
+ ['function outer() { throw ', '; }'],
+ ['const value = void\n', ';'],
+ ['const value = typeof\n', ';'],
+ ['const value = delete\n', ';'],
+ ['const value = new\n', ';'],
+ ['const value = !\n', ';'],
+ ['const value = ~\n', ';'],
+ ['const value = +\n', ';'],
+ ['const value = -\n', ';'],
+ ].map(([prefix, suffix]) => ({
+ code: `${prefix}${body} / import("./real")${suffix}`,
+ })),
+ ),
+)('keeps literal imports in expression division in $code', ({ code }) => {
+ // Given: each expression prefix is real syntax, not a token-only example.
+ new Bun.Transpiler({ loader: 'js' }).transformSync(code)
+ // When: scan without executing the expression or resolving its import.
+ const actual = scanImports(code, false)
+ // Then: division retains the literal import dependency.
+ expect(actual).toEqual([{ kind: 'dynamic', specifier: './real' }])
+})
diff --git a/packages/plugin-utils/src/__tests__/import-scanner-jsx-boundary.test.ts b/packages/plugin-utils/src/__tests__/import-scanner-jsx-boundary.test.ts
new file mode 100644
index 000000000..6d68cd7bd
--- /dev/null
+++ b/packages/plugin-utils/src/__tests__/import-scanner-jsx-boundary.test.ts
@@ -0,0 +1,18 @@
+import { expect, it } from 'bun:test'
+
+import { scanImports } from '../import-scanner'
+import { jsxBoundaryFixtures } from './jsx-boundary-fixtures'
+
+it.each([...jsxBoundaryFixtures])(
+ 'keeps independent edges when scanning $code',
+ ({ code, jsx, edges }) => {
+ // Given: syntax-checked source, never evaluated or used to derive expectations.
+ new Bun.Transpiler({ loader: jsx ? 'tsx' : 'ts' }).transformSync(code)
+ // When: scan the original source.
+ const actual = scanImports(code, jsx).map(
+ ({ kind, specifier }) => `${kind}:${specifier}`,
+ )
+ // Then: only the fixture's independently named edges survive.
+ expect(actual).toEqual([...edges])
+ },
+)
diff --git a/packages/plugin-utils/src/__tests__/import-scanner-jsx.test.ts b/packages/plugin-utils/src/__tests__/import-scanner-jsx.test.ts
new file mode 100644
index 000000000..e78ae7910
--- /dev/null
+++ b/packages/plugin-utils/src/__tests__/import-scanner-jsx.test.ts
@@ -0,0 +1,148 @@
+import { expect, it } from 'bun:test'
+
+import { scanImports } from '../import-scanner'
+
+it.each([
+ {
+ code: "const jsx = {import('phantom') && import('./real')}
;",
+ edges: ['dynamic:./real'],
+ },
+ {
+ code: "const jsx = {(import('phantom')) && import('./real')}
;",
+ edges: ['dynamic:./real'],
+ },
+ {
+ code: "const jsx = {require('phantom') && require('./required')}
;",
+ edges: ['static:./required'],
+ },
+ {
+ code: "const jsx = {(require('phantom')) && require('./required')}
;",
+ edges: ['static:./required'],
+ },
+ {
+ code: "const jsx = import('phantom')}>require('phantom'){import('./real')};",
+ edges: ['dynamic:./real'],
+ },
+ {
+ code: "const jsx = require('phantom')}>import('phantom'){require('./required')};",
+ edges: ['static:./required'],
+ },
+ {
+ code: "const jsx = && require('./required'))} label=\"import('phantom')\">require('phantom'){import('./real')};",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {ok ? import('phantom') : import('./real')}{require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {ok ? import('./real') : require('phantom')}{require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {({node: import('phantom'), leaf: import('./real')})}{require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {[import('phantom'), import('./real'), require('./required')]}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {call(require('phantom'), import('./real'), require('./required'))}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {<>import('phantom') && import('./real')}{require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = { && import('./real')}require('phantom'){require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {{import('phantom') && import('./real')}require('phantom') && require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = import('phantom')}>require('phantom'){import('./real')}}>import('phantom'){require('./required')};",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = } next={import('./real')} label='require("phantom")'/>; require('./required');",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = import('phantom'), leaf: import('./real')}}>require('phantom'){require('./required')};",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {(() => { const node = import('phantom'); return import('./real') })()}{require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {(() => require('phantom'))() && import('./real')}{require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {`${import('phantom') && import('./real')} require('phantom')`}{require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "const jsx = {!import('phantom') && import('./real')}{require('./required')}
;",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "async function f() { return {await import('phantom') && import('./real')}{require('./required')}
}",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+ {
+ code: "function* f() { return {(yield require('phantom')) && import('./real')}{require('./required')}
}",
+ edges: ['dynamic:./real', 'static:./required'],
+ },
+])(
+ 'keeps only real nested JSX edges when scanning $code',
+ ({ code, edges }) => {
+ // Given: valid TSX, checked without evaluating its imports or expressions.
+ new Bun.Transpiler({ loader: 'tsx' }).transformSync(code)
+ // When: scan the original source, not the compiler output.
+ const actual = scanImports(code, true)
+ .map((edge) => `${edge.kind}:${edge.specifier}`)
+ .sort()
+ // Then: fixture-derived dependencies exclude every text/quoted phantom.
+ expect(actual).toEqual([...edges])
+ },
+)
+
+it.each([
+ '~',
+ '+',
+ '-',
+ 'void ',
+ 'typeof ',
+ 'delete ',
+ '0 + ',
+ '0 - ',
+ '0 * ',
+ '0 / ',
+ '0 % ',
+ '0 ** ',
+ '0 ^ ',
+ '0 & ',
+ '0 | ',
+ '0 << ',
+ '0 > ',
+ '0 < ',
+ '0 in ',
+ '0 instanceof ',
+])('restores parent code when JSX follows expression prefix %s', (prefix) => {
+ // Given: valid unary/binary operand syntax surrounding nested JSX.
+ const code = `const jsx = {${prefix}import('phantom') && import('./real')}{require('./required')}
;`
+ new Bun.Transpiler({ loader: 'tsx' }).transformSync(code)
+ // When: scan the original operand expression.
+ const actual = scanImports(code, true)
+ // Then: expression operators neither leak text nor hide following dependencies.
+ expect(actual).toEqual([
+ { kind: 'dynamic', specifier: './real' },
+ { kind: 'static', specifier: './required' },
+ ])
+})
diff --git a/packages/plugin-utils/src/__tests__/import-scanner.test.ts b/packages/plugin-utils/src/__tests__/import-scanner.test.ts
new file mode 100644
index 000000000..dab92e615
--- /dev/null
+++ b/packages/plugin-utils/src/__tests__/import-scanner.test.ts
@@ -0,0 +1,147 @@
+import { expect, it } from 'bun:test'
+
+import { scanImports } from '../import-scanner'
+
+it.each([
+ {
+ code: 'export const result = `${import("./leaf")}`',
+ edges: ['dynamic:./leaf'],
+ },
+ {
+ code: 'export const result = `${require("./leaf")}`',
+ edges: ['static:./leaf'],
+ },
+ {
+ code: 'const s = `text ${ {a: `nested ${import("./a")}`, b: require("./b")} } tail import("fake")`',
+ edges: ['dynamic:./a', 'static:./b'],
+ },
+ {
+ code: 'const s = tag`escaped \\` \\${import("fake")} ${ /[`"}]/.test("}") ? import("./a") : require("./b") } tail`',
+ edges: ['dynamic:./a', 'static:./b'],
+ },
+ {
+ code: 'const s = `${ (() => { /* } ` */ // } `\n return import("./a") })() }`',
+ edges: ['dynamic:./a'],
+ },
+ {
+ code: 'const s = `${ import("fake"){import("./a")}
}`',
+ edges: ['dynamic:./a', 'static:./b'],
+ },
+ {
+ code: 'const a = 10 / import("./a"); const b = /[`"\']import("fake")/.test(a); const c = require("./b") / 2;',
+ edges: ['dynamic:./a', 'static:./b'],
+ },
+ {
+ code: 'const x = {a: 1} / import("./a"); x++ / require("./b"); --x / import("./c");',
+ edges: ['dynamic:./a', 'dynamic:./c', 'static:./b'],
+ },
+ {
+ code: 'if (x) { y() } /import("fake")/.test(x); while (x) /import("fake")/.test(x); import("./a")',
+ edges: ['dynamic:./a'],
+ },
+ {
+ code: 'const x = "import(\\"fake\\")"; /* require("fake") */ // import("fake")\n const y = <>require("fake")
{require("./b")};',
+ edges: ['static:./b'],
+ },
+ {
+ code: 'export*from"./a"; export{x}from"./b"; export * as ns from "./c"; import"./d";',
+ edges: ['static:./a', 'static:./b', 'static:./c', 'static:./d'],
+ },
+ {
+ code: 'import /*x*/ {x} /*y*/ from "./a"; require /*x*/ ( /*y*/ "./b" /*z*/ ); import("./c", {with:{type:"json"}});',
+ edges: ['dynamic:./c', 'static:./a', 'static:./b'],
+ },
+ {
+ code: 'import(name); require(name); import("./a" + name); require("./b" + name); import(`./c`); object.require("fake"); object?.import("fake");',
+ edges: [],
+ },
+ {
+ code: 'import(`${"fake"}`); require(`text ${"fake"}`); import(`text ${import("./a")}`);',
+ edges: ['dynamic:./a'],
+ },
+ {
+ code: 'import type {A} from "fake"; export type*from"fake"; import{type A,type B,}from"fake"; export{type A}from"fake"; import {type A,b} from "./a"; import Default,{type A}from"./b"; import type from "./c"; import{type as renamed}from"./d";',
+ edges: ['static:./a', 'static:./b', 'static:./c', 'static:./d'],
+ },
+ {
+ code: String.raw`import "./\x61"; export{x}from'./\u0062'; require('./\u{63}'); import("./quo\"te"); import('./quo\'te'); import('./back\\slash');`,
+ edges: [
+ 'dynamic:./quo"te',
+ "dynamic:./quo'te",
+ 'dynamic:./back\\slash',
+ 'static:./a',
+ 'static:./b',
+ 'static:./c',
+ ].sort(),
+ },
+ {
+ code: 'const s = `${ "}\\"" + /[}\\/`]/gi.test(x) + import("./a") } after`;',
+ edges: ['dynamic:./a'],
+ },
+ {
+ code: 'const s = `${ x in /import("fake")/ ? import("./a") : "" }`;',
+ edges: ['dynamic:./a'],
+ },
+ {
+ code: 'import from from "./a"; import {from} from "./b"; export {from as x} from "./c";',
+ edges: ['static:./a', 'static:./b', 'static:./c'],
+ },
+ {
+ code: 'import type, {value} from "./a"; import type, * as values from "./b"; import {"string-name" as name} from "./c"; export {name as "string-name"} from "./d";',
+ edges: ['static:./a', 'static:./b', 'static:./c', 'static:./d'],
+ },
+ {
+ code: 'const fn = function() {} / import("./a"); const C = class {} / require("./b");',
+ edges: ['dynamic:./a', 'static:./b'],
+ },
+ {
+ code: 'try {} finally {} /import("fake")/.test(x); class C {} /require("fake")/.test(x); function f() {} /import("fake")/.test(x); import("./a");',
+ edges: ['dynamic:./a'],
+ },
+ {
+ code: 'async function f() {} /import("fake")/.test(x); const fn = async function() {} / import("./a"); const g = function(a={x:1}, b=()=>{}) { return function() {} / require("./b") };',
+ edges: ['dynamic:./a', 'static:./b'],
+ },
+ {
+ code: 'export async /* marker */ function f() {} /import("phantom")/.test(value); import("./real");',
+ edges: ['dynamic:./real'],
+ },
+ {
+ code: 'const fn = async /*marker*/ function() {} / import("./real")',
+ edges: ['dynamic:./real'],
+ },
+ {
+ code: 'async/*marker*//*next*/function f() {} /import("phantom")/.test(value); import("./real");',
+ edges: ['dynamic:./real'],
+ },
+ {
+ code: 'const value = async /*marker*/ / import("./real") / 2; /*next*/ function f() {}',
+ edges: ['dynamic:./real'],
+ },
+])('discovers only fixture-derived edges in $code', ({ code, edges }) => {
+ // Given: independent expected edge sets, including text that resembles imports.
+ // When: scan without executing source or consulting a parser.
+ const actual = scanImports(code, true)
+ .map((edge) => `${edge.kind}:${edge.specifier}`)
+ .sort()
+ // Then: only literal dependencies in code are edges.
+ expect(actual).toEqual([...edges])
+})
+
+it('preserves TypeScript angle assertions without interpreting them as JSX', () => {
+ const code = 'const value = input / 2; import("./leaf")'
+ expect(scanImports(code, false)).toEqual([
+ { kind: 'dynamic', specifier: './leaf' },
+ ])
+})
+
+it('decodes escaped control characters and line continuations without evaluation', () => {
+ const code = String.raw`require('a\n\r\t\b\f\v\0\z'); import('a\
+b'); import('a\
+b');`
+ expect(scanImports(code, false)).toEqual([
+ { kind: 'static', specifier: 'a\n\r\t\b\f\v\0z' },
+ { kind: 'dynamic', specifier: 'ab' },
+ { kind: 'dynamic', specifier: 'ab' },
+ ])
+})
diff --git a/packages/plugin-utils/src/__tests__/import-type-fixtures.ts b/packages/plugin-utils/src/__tests__/import-type-fixtures.ts
new file mode 100644
index 000000000..34be6b3ed
--- /dev/null
+++ b/packages/plugin-utils/src/__tests__/import-type-fixtures.ts
@@ -0,0 +1,108 @@
+export const importTypeFixtures: readonly {
+ readonly code: string
+ readonly jsx: boolean
+ readonly edges: readonly string[]
+}[] = [
+ ...[
+ "type X = typeof import('./types');",
+ "type X = import('./types').T;",
+ "export type X = typeof import('./types');",
+ "export type X = import('./types').T;",
+ "type X = {value: import('./types').T; loader: typeof import('./types')};",
+ "type X = T extends import('./types').T ? import('./types').U : never;",
+ "type X = import('./types').T | import('./other-types').T;",
+ "type X = (value: import('./types').T) => import('./types').U;",
+ "type X = `prefix${import('./types').T}`;",
+ "interface X {value: import('./types').T; loader: typeof import('./types')}",
+ "type X = typeof /* marker */ import /* next */ ('./types');",
+ "type X = typeof import('./types')\n",
+ ].map((prefix) => ({
+ code: `${prefix}\nconst x = typeof import('./real'); require('./required');`,
+ jsx: false,
+ edges: ['dynamic:./real', 'static:./required'],
+ })),
+ ...[
+ "const x: import('./types').T = import('./real');",
+ "const x: typeof import('./types') = typeof import('./real');",
+ "let x: Promise = import('./real');",
+ "const x: T extends U ? import('./types').T : never = import('./real');",
+ "const f = (x: () => import('./types').T = () => import('./real')) => import('./body');",
+ "const x = import('./real') as {fn: () => import('./types').T};",
+ "const x = import('./real') as (() => import('./types').T);",
+ "const x = f(import('./real'));",
+ "function f(x = import('./real')) {return import('./body')}",
+ "const f = (x = import('./real')) => import('./body');",
+ "const x = import('./real');",
+ "const x = a < import('./real');",
+ "class C extends mixin({value: import('./real')}) {f() {return import('./body')}}",
+ "type X = typeof import('./types')\nimport('./real');",
+ "type X = import('./types').T\nimport('./real');",
+ "function f(x: import('./types').T = import('./real')) {return import('./body')}",
+ "function f(x: import('./types').T = import('./real')): Promise {return import('./body')}",
+ "const f = (x: import('./types').T = import('./real')): Promise => import('./body');",
+ "function f({x}: import('./types').T = import('./real')) {return import('./body')}",
+ "class C {x: import('./types').T = import('./real'); f(x: import('./types').T) {return import('./body')}}",
+ "const x = import('./real') as import('./types').T;",
+ "const x = import('./real') satisfies import('./types').T;",
+ "const x = {type: typeof import('./real'), value: import('./body')};",
+ "const f = (x = typeof import('./real')) => import('./body');",
+ "const x = typeof import('./real');",
+ "const x = ok ? f() : typeof import('./real');",
+ "const x = ok ? f(import('./body')) : import('./real');",
+ "const x = ok ? f() : ((x = import('./real')) => x);",
+ "const as = (x) => x; const x = as(import('./real'));",
+ "const satisfies = (x) => x; const x = satisfies(import('./real'));",
+ "const x = {as: typeof import('./real')};",
+ "obj.class; const x = {value: import('./real')};",
+ "const x = {interface: import('./real'), const: import('./body')};",
+ "const x = import('./real') as import('./types').T && import('./body');",
+ "const x = import('./real') as number ? import('./body') : null;",
+ "const x = ok ? (f()) : import('./real');",
+ "const x = ok ? (value) : typeof import('./real');",
+ "const x = ok ? ((f(g()))) : import('./real');",
+ "const x = ok ? (f(import('./body'))) : import('./real');",
+ "const x = ok ? (value) : {loader: import('./real')};",
+ "const x = ok ? (value) : (() => import('./real'));",
+ "const x = ok ? (value) : (x) => import('./real');",
+ "const x = ok ? (value) : other ? (f()) : import('./real');",
+ "const x = ok ? (value) : typeof (import('./real'));",
+ "const x = ok ? (value) : (x = import('./real')): import('./types').T => x;",
+ "const x = ok ? f() : (x = import('./real')): import('./types').T => x;",
+ "const x = ok ? (value) : (): {loader: import('./types').T} => ({loader: import('./real')});",
+ "const x = {async f(): import('./types').T {return import('./real')}};",
+ "class C {async f(): import('./types').T {return import('./real')}}",
+ "const x = {async f(x: import('./types').T = import('./real')): Promise {return import('./body')}};",
+ "class C {static async f(x: import('./types').T = import('./real')): Promise {return import('./body')}}",
+ "const f = async (x: import('./types').T = import('./real')): Promise => import('./body');",
+ "async function f(x: import('./types').T = import('./real')): Promise {return import('./body')}",
+ "function f(): import('./types').T; function f() {return import('./real')}",
+ ].map((code) => ({
+ code,
+ jsx: false,
+ edges: code.includes('f(import')
+ ? ['dynamic:./body', 'dynamic:./real']
+ : code.includes('./body')
+ ? ['dynamic:./real', 'dynamic:./body']
+ : ['dynamic:./real'],
+ })),
+ {
+ code: "type X = import('./types').T",
+ jsx: false,
+ edges: [],
+ },
+ {
+ code: "type X = import('./types').T; const x = typeof import('./types');",
+ jsx: false,
+ edges: ['dynamic:./types'],
+ },
+ {
+ code: "const x: import('./types').T = 
-