@openrewrite/rewrite 8.91.0 → 8.91.1

package/src/javascript/assertions.ts

@@ -34,6 +34,19 @@ import {Marker, replaceMarkerByKind} from "../markers";
  */
 export const sourceFileCache: Map<string, ts.SourceFile> = new Map();
 
+// Pooled so a spec reuses the program the previous spec left behind; see `JavaScriptParser.parse`.
+const parserPool: Map<string, JavaScriptParser> = new Map();
+
+function pooledParser(relativeTo?: string): JavaScriptParser {
+    const key = relativeTo ?? "";
+    let parser = parserPool.get(key);
+    if (!parser) {
+        parser = new JavaScriptParser({sourceFileCache, relativeTo});
+        parserPool.set(key, parser);
+    }
+    return parser;
+}
+
 // Automatically enable sourceFileCache for template parsing in tests
 setTemplateSourceFileCache(sourceFileCache);
 
@@ -211,7 +224,7 @@ export async function* npm(relativeTo: string, ...sourceSpecs: SourceSpec<any>[]
 
                 yield {
                     ...spec,
-                    parser: () => new JavaScriptParser({sourceFileCache, relativeTo}),
+                    parser: () => pooledParser(relativeTo),
                     // Add style marker before recipe runs if available
                     // Compose with existing beforeRecipe if present
                     beforeRecipe: styleMarker ? (sf: JS.CompilationUnit) => {
@@ -243,13 +256,28 @@ export function packageLockJson(before: string, after?: AfterRecipeText): Source
     };
 }
 
+/**
+ * Gives a source file the style its own text is written in. A spec that formats its output is
+ * measured against the built-in defaults unless it opts in with
+ * `{...typescript(src), beforeRecipe: withDetectedStyle}`; a file parsed through {@link npm} is
+ * sampled alongside its siblings and needs no opt-in.
+ */
+export async function withDetectedStyle(sourceFile: JS.CompilationUnit): Promise<JS.CompilationUnit> {
+    const detector = Autodetect.detector();
+    await detector.sample(sourceFile);
+    const detected = detector.build();
+    return produce(sourceFile, draft => {
+        draft.markers = replaceMarkerByKind(draft.markers, detected);
+    });
+}
+
 export function javascript(before: string | null, after?: AfterRecipeText): SourceSpec<JS.CompilationUnit> {
     return {
         kind: JS.Kind.CompilationUnit,
         before: before,
         after: dedentAfter(after),
         ext: 'js',
-        parser: ctx => new JavaScriptParser({sourceFileCache})
+        parser: ctx => pooledParser()
     };
 }
 
@@ -259,7 +287,7 @@ export function typescript(before: string | null, after?: AfterRecipeText): Sour
         before: before,
         after: dedentAfter(after),
         ext: 'ts',
-        parser: () => new JavaScriptParser({sourceFileCache})
+        parser: () => pooledParser()
     };
 }
 
@@ -269,7 +297,7 @@ export function tsx(before: string | null, after?: AfterRecipeText): SourceSpec<
         before: before,
         after: dedentAfter(after),
         ext: 'tsx',
-        parser: () => new JavaScriptParser({sourceFileCache})
+        parser: () => pooledParser()
     };
 }
 
@@ -279,6 +307,6 @@ export function jsx(before: string | null, after?: AfterRecipeText): SourceSpec<
         before: before,
         after: dedentAfter(after),
         ext: 'jsx',
-        parser: () => new JavaScriptParser({sourceFileCache})
+        parser: () => pooledParser()
     };
 }

package/src/javascript/comparator.ts

@@ -2410,11 +2410,6 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
                 }
             }
 
-            // If neither has type, use structural comparison
-            if (!method.methodType && !otherMethod.methodType) {
-                return super.visitMethodInvocation(method, other);
-            }
-
             // If both have types with FQ declaring types, verify they're compatible
             // (This prevents matching completely different methods like util.isArray vs util.isBoolean)
             if (method.methodType && otherMethod.methodType) {
@@ -2450,12 +2445,12 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         }
         // else: types matched, skip select comparison (allows namespace vs named imports)
 
-        // Compare type parameters
-        if ((method.typeParameters === undefined) !== (otherMethod.typeParameters === undefined)) {
-            return this.structuralMismatch('typeParameters');
-        }
+        // A pattern that spells out no type arguments says nothing about them, as with parentheses
+        if (method.typeParameters) {
+            if (!otherMethod.typeParameters) {
+                return this.structuralMismatch('typeParameters');
+            }
 
-        if (method.typeParameters && otherMethod.typeParameters) {
             await this.visitContainerProperty('typeParameters', method.typeParameters, otherMethod.typeParameters);
             if (!this.match) return method;
         }
@@ -2475,6 +2470,32 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         return method;
     }
 
+    /**
+     * A call whose callee is not a plain identifier, such as `getFn()(x)`, `arr[0](x)` or `fn?.(x)`.
+     * Type arguments constrain it under the same rule as `visitMethodInvocation`.
+     */
+    override async visitFunctionCall(functionCall: JS.FunctionCall, other: J): Promise<J | undefined> {
+        if (other.kind !== JS.Kind.FunctionCall) {
+            return this.kindMismatch();
+        }
+
+        const otherFunctionCall = other as JS.FunctionCall;
+        if (functionCall.typeParameters) {
+            if (!otherFunctionCall.typeParameters) {
+                return this.structuralMismatch('typeParameters');
+            }
+
+            await this.visitContainerProperty('typeParameters', functionCall.typeParameters, otherFunctionCall.typeParameters);
+            if (!this.match) return functionCall;
+        }
+
+        // Type arguments are settled, so they come off both sides and the rest compares property by property
+        const patternCall: JS.FunctionCall = {...functionCall, typeParameters: undefined};
+        const targetCall: JS.FunctionCall = {...otherFunctionCall, typeParameters: undefined};
+        await super.visitFunctionCall(patternCall, targetCall);
+        return functionCall;
+    }
+
     /**
      * Override identifier comparison to include:
      * 1. Type checking for field access
@@ -2520,6 +2541,10 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
      * code with typeExpression.
      */
     override async visitVariableDeclarations(variableDeclarations: J.VariableDeclarations, other: J): Promise<J | undefined> {
+        if (other.kind !== J.Kind.VariableDeclarations) {
+            return this.kindMismatch();
+        }
+
         const otherVariableDeclarations = other as J.VariableDeclarations;
 
         // Visit leading annotations
@@ -2578,6 +2603,10 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
      * code with returnTypeExpression.
      */
     override async visitMethodDeclaration(methodDeclaration: J.MethodDeclaration, other: J): Promise<J | undefined> {
+        if (other.kind !== J.Kind.MethodDeclaration) {
+            return this.kindMismatch();
+        }
+
         const otherMethodDeclaration = other as J.MethodDeclaration;
 
         // Visit leading annotations

package/src/javascript/format/format.ts

@@ -17,7 +17,7 @@ import {JS} from "../tree";
 import {JavaScriptVisitor} from "../visitor";
 import {Comment, J, lastWhitespace, replaceLastWhitespace, Statement} from "../../java";
 import {create as produce, Draft} from "mutative";
-import {Cursor, isScope, Tree} from "../../tree";
+import {Cursor, isScope, isSourceFile, Tree} from "../../tree";
 import {BlankLinesStyle, getStyle, SpacesStyle, StyleKind, TabsAndIndentsStyle, WrappingAndBracesStyle} from "../style";
 import {NamedStyles} from "../../style";
 import {produceAsync} from "../../visitor";
@@ -74,13 +74,16 @@ export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
             return applyPrettierFormatting(tree as R, prettierStyle, p, cursor, this.stopAfter);
         }
 
+        // Style markers live on the source file, which is `tree` itself only when a whole file is being formatted
+        const styleSource = (isSourceFile(tree) ? tree : cursor?.firstEnclosing(isSourceFile)) ?? tree;
+
         const visitors = [
             new NormalizeWhitespaceVisitor(this.stopAfter),
             new MinimumViableSpacingVisitor(this.stopAfter),
-            new BlankLinesVisitor(getStyle(StyleKind.BlankLinesStyle, tree, this.styles) as BlankLinesStyle, this.stopAfter),
-            new WrappingAndBracesVisitor(getStyle(StyleKind.WrappingAndBracesStyle, tree, this.styles) as WrappingAndBracesStyle, this.stopAfter),
-            new SpacesVisitor(getStyle(StyleKind.SpacesStyle, tree, this.styles) as SpacesStyle, this.stopAfter),
-            new TabsAndIndentsVisitor(getStyle(StyleKind.TabsAndIndentsStyle, tree, this.styles) as TabsAndIndentsStyle, this.stopAfter),
+            new BlankLinesVisitor(getStyle(StyleKind.BlankLinesStyle, styleSource, this.styles) as BlankLinesStyle, this.stopAfter),
+            new WrappingAndBracesVisitor(getStyle(StyleKind.WrappingAndBracesStyle, styleSource, this.styles) as WrappingAndBracesStyle, this.stopAfter),
+            new SpacesVisitor(getStyle(StyleKind.SpacesStyle, styleSource, this.styles) as SpacesStyle, this.stopAfter),
+            new TabsAndIndentsVisitor(getStyle(StyleKind.TabsAndIndentsStyle, styleSource, this.styles) as TabsAndIndentsStyle, this.stopAfter),
         ]
 
         let t: R | undefined = tree as R;
@@ -227,11 +230,7 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
                 // Apply beforeComma rule to all elements except the last
                 // (last element's after is before closing bracket, not a comma)
                 for (let i = 0; i < draft.elements.length - 1; i++) {
-                    const afterWs = draft.elements[i].after.whitespace;
-                    // Preserve newlines - only adjust when on same line
-                    if (!afterWs.includes("\n")) {
-                        draft.elements[i].after.whitespace = this.style.other.beforeComma ? " " : "";
-                    }
+                    this.spaceAfterRightPaddedDraft(draft.elements[i], this.style.other.beforeComma);
                 }
             }
             if (draft.elements.length > 1) {

package/src/javascript/format/tabs-and-indents-visitor.ts

@@ -22,7 +22,6 @@ import {
     lastWhitespace,
     normalizeSpaceIndent,
     replaceIndentAfterLastNewline,
-    replaceLastWhitespace,
     spaceContainsNewline,
     stripLeadingIndent
 } from "../../java";
@@ -45,6 +44,11 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         this.useTabCharacter = this.tabsAndIndentsStyle.useTabCharacter;
     }
 
+    /** Width of existing indent whitespace in the unit {@link indentString} takes, where a tab is one indent. */
+    private indentWidth(indent: string): number {
+        return [...indent].reduce((width, ch) => width + (ch === "\t" ? this.indentSize : 1), 0);
+    }
+
     private indentString(indent: number): string {
         if (this.useTabCharacter) {
             return "\t".repeat(Math.floor(indent / this.indentSize));
@@ -395,12 +399,12 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     }
 
     private normalizeBlockEnd(block: J.Block, myIndent: number): J.Block {
-        const effectiveLastWs = lastWhitespace(block.end);
-        if (!effectiveLastWs.includes("\n")) {
+        if (!spaceContainsNewline(block.end)) {
             return block;
         }
-        return produce(block, draft => {
-            draft.end = replaceLastWhitespace(draft.end, ws => replaceIndentAfterLastNewline(ws, this.indentString(myIndent)));
+        const end = normalizeSpaceIndent(block.end, this.indentString(myIndent), this.indentString(myIndent + this.indentSize));
+        return end === block.end ? block : produce(block, draft => {
+            draft.end = end;
         });
     }
 
@@ -440,12 +444,14 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         // Normalize the last element's after whitespace (closing delimiter like `)`)
         // The closing delimiter should align with the parent's indent level
         if (container.elements.length > 0) {
-            const effectiveLastWs = lastWhitespace(container.elements[container.elements.length - 1].after);
-            if (effectiveLastWs.includes("\n")) {
-                return produce(container, draft => {
-                    const lastDraft = draft.elements[draft.elements.length - 1];
-                    lastDraft.after = replaceLastWhitespace(lastDraft.after, ws => replaceIndentAfterLastNewline(ws, this.indentString(parentIndent)));
-                });
+            const last = container.elements[container.elements.length - 1];
+            if (spaceContainsNewline(last.after)) {
+                const after = normalizeSpaceIndent(last.after, this.indentString(parentIndent), this.indentString(parentIndent + this.indentSize));
+                if (after !== last.after) {
+                    return produce(container, draft => {
+                        draft.elements[draft.elements.length - 1].after = after;
+                    });
+                }
             }
         }
 
@@ -646,7 +652,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
                 const idx = ws.lastIndexOf('\n');
                 if (idx !== -1) {
                     anchorCursor = c;
-                    anchorIndent = ws.length - idx - 1;
+                    anchorIndent = this.indentWidth(ws.substring(idx + 1));
                 }
             }
 

package/src/javascript/node-resolution-result.ts

@@ -60,13 +60,65 @@ export interface PackageLockEntry {
 }
 
 /**
- * Parsed package-lock.json content structure (npm lockfile v3 format).
+ * Entry in a legacy npm lockfileVersion 1 `dependencies` tree (npm 5/6), with its
+ * requirements under `requires` and nested conflicting versions under `dependencies`.
+ */
+export interface LockfileV1Entry {
+    readonly version?: string;
+    readonly resolved?: string;
+    readonly integrity?: string;
+    readonly license?: string | string[] | { type?: string; url?: string };
+    readonly engines?: Record<string, string> | string[];
+    readonly requires?: Record<string, string>;
+    readonly dependencies?: Record<string, LockfileV1Entry>;
+}
+
+/**
+ * Parsed package-lock.json content structure. The `packages` map is the modern
+ * (lockfileVersion 2/3) shape; `dependencies` is the legacy lockfileVersion 1 tree.
  */
 export interface PackageLockContent {
     readonly name?: string;
     readonly version?: string;
     readonly lockfileVersion?: number;
     readonly packages?: Record<string, PackageLockEntry>;
+    readonly dependencies?: Record<string, LockfileV1Entry>;
+}
+
+/**
+ * Converts a legacy npm lockfileVersion 1 `dependencies` tree into the modern
+ * `packages` map keyed by node_modules path, so the resolver can walk transitive
+ * dependencies the same way it does for lockfileVersion 2/3 files. Returns
+ * undefined when the tree is absent or empty.
+ */
+function convertV1DependencyTree(
+    tree: Record<string, LockfileV1Entry> | undefined
+): Record<string, PackageLockEntry> | undefined {
+    if (!tree || Object.keys(tree).length === 0) {
+        return undefined;
+    }
+    const packages: Record<string, PackageLockEntry> = {};
+
+    function walk(deps: Record<string, LockfileV1Entry>, pathPrefix: string): void {
+        for (const [name, entry] of Object.entries(deps)) {
+            const pkgPath = `${pathPrefix}node_modules/${name}`;
+            packages[pkgPath] = {
+                version: entry.version,
+                resolved: entry.resolved,
+                integrity: entry.integrity,
+                license: entry.license,
+                engines: entry.engines,
+                // v1 folds all declared deps into `requires`; the resolver reads `dependencies`.
+                dependencies: entry.requires,
+            };
+            if (entry.dependencies) {
+                walk(entry.dependencies, `${pkgPath}/`);
+            }
+        }
+    }
+
+    walk(tree, "");
+    return packages;
 }
 
 /**
@@ -524,9 +576,12 @@ export function createNodeResolutionResultMarker(
     function parseResolutions(
         lockContent: PackageLockContent
     ): ResolvedDependency[] {
-        if (!lockContent.packages) return [];
-
-        const packages = lockContent.packages;
+        // Prefer the modern `packages` map; fall back to converting a legacy
+        // lockfileVersion 1 `dependencies` tree when no `packages` map is present.
+        const packages = lockContent.packages && Object.keys(lockContent.packages).length > 0
+            ? lockContent.packages
+            : convertV1DependencyTree(lockContent.dependencies);
+        if (!packages) return [];
 
         // First pass: Create all ResolvedDependency placeholders and build path map
         const packageInfos: Array<{ path: string; name: string; version: string; entry: PackageLockEntry }> = [];

package/src/javascript/package-exported-types.ts

@@ -18,6 +18,8 @@ import * as path from "path";
 import {Type} from "../java";
 import {JavaScriptTypeMapping} from "./type-mapping";
 
+const TYPESCRIPT_FILE = /\.[cm]?tsx?$/;
+
 // Free functions are not exported-type entries; only nominal types (and value modules, which are
 // descended into for nested types) qualify.
 const TYPE_SYMBOL_FLAGS =
@@ -38,21 +40,13 @@ const TYPE_SYMBOL_FLAGS =
  * @param references node_modules roots / sibling packages used only for symbol resolution
  */
 export function exportedTypes(ownArtifacts: string[], references: string[]): Type.FullyQualified[] {
-    const entries: string[] = [];
-    for (const artifact of ownArtifacts) {
-        const entry = declarationFileEntry(artifact) ?? resolvePackageEntry(artifact);
-        if (entry) {
-            entries.push(path.normalize(entry));
-        }
-    }
-    if (entries.length === 0) {
-        return [];
-    }
-
     const compilerOptions: ts.CompilerOptions = {
         target: ts.ScriptTarget.Latest,
-        module: ts.ModuleKind.CommonJS,
-        moduleResolution: ts.ModuleResolutionKind.Node10,
+        // Mirrors JavaScriptParser's module resolution, so a dependency's own imports resolve here
+        // as they do when its consumers are parsed; the rationale for each option lives there.
+        module: ts.ModuleKind.Preserve,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        customConditions: ["node"],
         noEmit: true,
         allowJs: true,
         checkJs: false,
@@ -80,6 +74,17 @@ export function exportedTypes(ownArtifacts: string[], references: string[]): Typ
             return resolved;
         });
 
+    const entries: string[] = [];
+    for (const artifact of ownArtifacts) {
+        const entry = declarationFileEntry(artifact) ?? resolvePackageEntry(artifact, compilerOptions, host);
+        if (entry) {
+            entries.push(path.normalize(entry));
+        }
+    }
+    if (entries.length === 0) {
+        return [];
+    }
+
     const program = ts.createProgram(entries, compilerOptions, host);
     const checker = program.getTypeChecker();
     const typeMapping = new JavaScriptTypeMapping(checker);
@@ -156,7 +161,7 @@ function arity(cls: Type.Class): number {
 
 /** A TypeScript declaration/source FILE (e.g. a `lib.*.d.ts` of ambient globals), used directly as a program entry. */
 function declarationFileEntry(artifact: string): string | undefined {
-    return ts.sys.fileExists(artifact) && /\.[cm]?tsx?$/.test(artifact) ? artifact : undefined;
+    return ts.sys.fileExists(artifact) && TYPESCRIPT_FILE.test(artifact) ? artifact : undefined;
 }
 
 /** Top-level ambient type declarations of a script (non-module) file — a `lib.*.d.ts`'s globals; namespaces descended for nested types. */
@@ -186,30 +191,34 @@ function globalTypeSymbols(checker: ts.TypeChecker, sourceFile: ts.SourceFile):
 }
 
 /**
- * Resolve a package directory to its declaration entry: the package.json `types`/`typings`
- * field, else the `exports["."]` types condition (modern packages declare types only there),
- * else a top-level `index.d.ts` (then `index.ts`).
+ * A package directory's declaration entry, found by resolving the package's own name from inside
+ * it so `types`, `exports` conditions and `typesVersions` all apply; else the declared `types`
+ * file; else a top-level `index.d.ts` (then `index.ts`). Reaching none of them means the package
+ * ships no types, which leaves the caller to fall back to its DefinitelyTyped package.
  */
-function resolvePackageEntry(dir: string): string | undefined {
-    const packageJson = path.join(dir, "package.json");
-    if (ts.sys.fileExists(packageJson)) {
-        try {
-            const pkg = JSON.parse(ts.sys.readFile(packageJson) || "{}");
-            const typesField: unknown = pkg.types ?? pkg.typings;
-            const candidate = typeof typesField === "string"
-                ? typesField
-                : exportsTypesEntry(pkg.exports);
-            if (typeof candidate === "string") {
-                const resolved = path.resolve(dir, candidate);
-                if (ts.sys.fileExists(resolved)) {
-                    return resolved;
-                }
-                if (ts.sys.fileExists(resolved + ".d.ts")) {
-                    return resolved + ".d.ts";
-                }
+function resolvePackageEntry(dir: string, options: ts.CompilerOptions, host: ts.ModuleResolutionHost): string | undefined {
+    const manifest = packageManifest(dir);
+    if (typeof manifest?.name === "string") {
+        const conditions = options.customConditions ?? [];
+        // A package's declarations count under whichever condition carries them, since no
+        // consumer's import mode is choosing between `import` and `require` here.
+        for (const attempt of [conditions, [...conditions, "require"]]) {
+            const resolved = ts.resolveModuleName(manifest.name, path.join(dir, "__entry__.ts"),
+                {...options, customConditions: attempt}, host).resolvedModule?.resolvedFileName;
+            if (resolved && TYPESCRIPT_FILE.test(resolved) && containedIn(dir, resolved)) {
+                return resolved;
+            }
+        }
+    }
+    // An `exports` map without a `types` condition takes resolution to the runtime entry and stops
+    // it there, while `types` still names the declarations.
+    const declared = manifest?.types ?? manifest?.typings;
+    if (typeof declared === "string") {
+        const resolved = path.resolve(dir, declared);
+        for (const candidate of [resolved, resolved + ".d.ts"]) {
+            if (ts.sys.fileExists(candidate)) {
+                return candidate;
             }
-        } catch {
-            // Malformed package.json; fall through to conventional entry points.
         }
     }
     for (const candidate of ["index.d.ts", "index.ts", "index.tsx"]) {
@@ -221,49 +230,26 @@ function resolvePackageEntry(dir: string): string | undefined {
     return undefined;
 }
 
-/** The declaration file for the package's `.` subpath from its `exports` map, if any. */
-function exportsTypesEntry(exports: unknown): string | undefined {
-    if (typeof exports === "string") {
-        return typesFromCondition(exports);
-    }
-    if (!exports || typeof exports !== "object") {
-        return undefined;
-    }
-    const map = exports as Record<string, unknown>;
-    // `exports["."]`, or the whole object when it is condition-only sugar (no subpath keys).
-    const dot = "." in map
-        ? map["."]
-        : (Object.keys(map).some(k => k.startsWith(".")) ? undefined : map);
-    return dot === undefined ? undefined : typesFromCondition(dot);
-}
-
 /**
- * Pull a declaration file out of an `exports` condition value: an explicit `types` condition,
- * else the `types` nested under `import`/`require`/`default`. A bare target string is a runtime
- * (JS) entry, not types, unless it is itself a declaration file.
+ * Whether `file` belongs to the package installed at `dir`. Resolution by name walks up the tree,
+ * so a same-named package elsewhere can answer — which an npm alias (`"a": "npm:b@1"`) installs by
+ * construction.
  */
-function typesFromCondition(entry: unknown): string | undefined {
-    if (typeof entry === "string") {
-        return /\.d\.[cm]?ts$/.test(entry) ? entry : undefined;
-    }
-    if (!entry || typeof entry !== "object") {
+function containedIn(dir: string, file: string): boolean {
+    return path.resolve(file).startsWith(path.resolve(dir) + path.sep);
+}
+
+function packageManifest(dir: string): {name?: unknown, types?: unknown, typings?: unknown} | undefined {
+    const packageJson = path.join(dir, "package.json");
+    if (!ts.sys.fileExists(packageJson)) {
         return undefined;
     }
-    const o = entry as Record<string, unknown>;
-    if (typeof o.types === "string") {
-        return o.types;
-    }
-    const nestedTypes = typesFromCondition(o.types);
-    if (nestedTypes) {
-        return nestedTypes;
-    }
-    for (const cond of ["import", "require", "default"]) {
-        const nested = typesFromCondition(o[cond]);
-        if (nested) {
-            return nested;
-        }
+    try {
+        return JSON.parse(ts.sys.readFile(packageJson) || "{}");
+    } catch {
+        // Malformed package.json; fall through to conventional entry points.
+        return undefined;
     }
-    return undefined;
 }
 
 /**

package/src/javascript/parser.ts

@@ -91,8 +91,14 @@ export class JavaScriptParser extends Parser {
         super({ctx, relativeTo});
         this.compilerOptions = {
             target: ts.ScriptTarget.Latest,
-            module: ts.ModuleKind.CommonJS,
-            moduleResolution: ts.ModuleResolutionKind.Node10,
+            // Bundler matches `exports` conditions leniently, so packages that publish types only under
+            // an `import` condition resolve; it pairs with `preserve`, which `commonjs` cannot (TS5095).
+            // A `node16` module kind makes TS1479 reachable, and that error costs the whole LST.
+            module: ts.ModuleKind.Preserve,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            // Bundler's own condition set omits `node`, which takes the browser branch of packages
+            // that publish one, typing them against an API surface the source does not use.
+            customConditions: ["node"],
             noEmit: true,
             allowJs: true,
             checkJs: true,
@@ -326,7 +332,8 @@ export class JavaScriptParser extends Parser {
             return resolvedModules;
         };
 
-        // Create a new Program, passing the oldProgram for incremental parsing
+        // TypeScript carries the previous program's bound files forward when the root paths match,
+        // so a parser held across parses of one path costs a fraction of a freshly built one.
         const program = ts.createProgram([...inputFiles.keys()], this.compilerOptions, host, this.oldProgram);
 
         // Update the oldProgram reference

package/src/javascript/recipes/change-import.ts

@@ -164,17 +164,14 @@ export class ChangeImport extends Recipe {
                             alias: aliasToUse,
                             onlyIfReferenced: false
                         });
-                    } else if (aliasToUse && aliasToUse !== newMember) {
-                        maybeAddImport(this, {
-                            module: newModule,
-                            member: newMember,
-                            alias: aliasToUse,
-                            onlyIfReferenced: false
-                        });
                     } else {
                         maybeAddImport(this, {
                             module: newModule,
                             member: newMember,
+                            // A moved binding keeps the local name it had. Pinning it also tells
+                            // `maybeAddImport` not to deconflict against the import being replaced,
+                            // which is still present in the tree it reads.
+                            alias: aliasToUse ?? newMember,
                             onlyIfReferenced: false
                         });
                     }

package/src/javascript/style.ts

@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-import {NamedStyles, Style} from "../style";
+import {isNamedStyles, NamedStyles, Style} from "../style";
 import {randomId} from "../uuid";
 import {Tree} from "../tree";
-import {MarkersKind} from "../markers";
 
 export const JavaScriptStyles = {
     IntelliJ: "org.openrewrite.javascript.style.IntelliJ",
@@ -562,13 +561,7 @@ export namespace IntelliJ {
 }
 
 export function styleFromSourceFile(styleKind: string, sourceFile: Tree): Style | undefined {
-    const namedStyles = sourceFile.markers.markers.filter(marker => marker.kind === MarkersKind.NamedStyles) as NamedStyles[];
-    const candidate = namedStyles.map(namedStyle => namedStyle.styles).flat()
-        .find(style => style.kind === styleKind)
-    if (candidate) {
-        return candidate;
-    }
-    return IntelliJ.TypeScript.defaults.styles.find(style => style.kind === styleKind) as Style;
+    return getStyle(styleKind, sourceFile);
 }
 
 /**
@@ -591,8 +584,7 @@ export function getStyle(styleKind: string, sourceFile: Tree, styles?: NamedStyl
     }
 
     // Then check source file markers
-    const namedStyles = sourceFile.markers.markers.filter(marker => marker.kind === MarkersKind.NamedStyles) as NamedStyles[];
-    for (const namedStyle of namedStyles) {
+    for (const namedStyle of sourceFile.markers.markers.filter(isNamedStyles)) {
         const found = namedStyle.styles.find(s => s.kind === styleKind);
         if (found) {
             return found;