@openrewrite/rewrite 8.67.0 → 8.67.1

package/src/javascript/parser.ts

@@ -366,6 +366,26 @@ export class JavaScriptParserVisitor {
             }
         }
 
+        let shebangStatement: J.RightPadded<JS.Shebang> | undefined;
+        if (prefix.whitespace?.startsWith('#!')) {
+            const newlineIndex = prefix.whitespace.indexOf('\n');
+            const shebangText = newlineIndex === -1 ? prefix.whitespace : prefix.whitespace.slice(0, newlineIndex);
+            const afterShebang = newlineIndex === -1 ? '' : '\n';
+            const remainingWhitespace = newlineIndex === -1 ? '' : prefix.whitespace.slice(newlineIndex + 1);
+
+            shebangStatement = this.rightPadded<JS.Shebang>({
+                kind: JS.Kind.Shebang,
+                id: randomId(),
+                prefix: emptySpace,
+                markers: emptyMarkers,
+                text: shebangText
+            }, {kind: J.Kind.Space, whitespace: afterShebang, comments: []}, emptyMarkers);
+
+            prefix = produce(prefix, draft => {
+                draft.whitespace = remainingWhitespace;
+            });
+        }
+
         return {
             kind: JS.Kind.CompilationUnit,
             id: randomId(),
@@ -374,7 +394,9 @@ export class JavaScriptParserVisitor {
             sourcePath: this.sourcePath,
             charsetName: bomAndTextEncoding.encoding,
             charsetBomMarked: bomAndTextEncoding.hasBom,
-            statements: this.semicolonPaddedStatementList(node.statements),
+            statements: shebangStatement
+                ? [shebangStatement, ...this.semicolonPaddedStatementList(node.statements)]
+                : this.semicolonPaddedStatementList(node.statements),
             eof: this.prefix(node.endOfFileToken)
         };
     }

package/src/javascript/print.ts

@@ -459,6 +459,13 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         return variableDeclarations;
     }
 
+    override async visitShebang(shebang: JS.Shebang, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(shebang, p);
+        p.append(shebang.text);
+        await this.afterSyntax(shebang, p);
+        return shebang;
+    }
+
     override async visitVariableDeclarations(multiVariable: J.VariableDeclarations, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(multiVariable, p);
         await this.visitNodes(multiVariable.leadingAnnotations, p);

package/src/javascript/rpc.ts

@@ -247,6 +247,11 @@ class JavaScriptSender extends JavaScriptVisitor<RpcSendQueue> {
         return scopedVariableDeclarations;
     }
 
+    override async visitShebang(shebang: JS.Shebang, q: RpcSendQueue): Promise<J | undefined> {
+        await q.getAndSend(shebang, el => el.text);
+        return shebang;
+    }
+
     override async visitStatementExpression(statementExpression: JS.StatementExpression, q: RpcSendQueue): Promise<J | undefined> {
         await q.getAndSend(statementExpression, el => el.statement, el => this.visit(el, q));
         return statementExpression;
@@ -828,6 +833,13 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         return updateIfChanged(scopedVariableDeclarations, updates);
     }
 
+    override async visitShebang(shebang: JS.Shebang, q: RpcReceiveQueue): Promise<J | undefined> {
+        const updates = {
+            text: await q.receive(shebang.text)
+        };
+        return updateIfChanged(shebang, updates);
+    }
+
     override async visitStatementExpression(statementExpression: JS.StatementExpression, q: RpcReceiveQueue): Promise<J | undefined> {
         const updates = {
             statement: await q.receive(statementExpression.statement, el => this.visitDefined<Statement>(el, q))

package/src/javascript/templating/pattern.ts

@@ -616,6 +616,17 @@ export class MatchResult implements IMatchResult {
         return this.extractElements(value);
     }
 
+    /**
+     * Checks if a capture has been matched.
+     *
+     * @param capture The capture name (string) or Capture object
+     * @returns true if the capture exists in the match result
+     */
+    has(capture: Capture | string): boolean {
+        const name = typeof capture === "string" ? capture : ((capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName());
+        return this.storage.has(name);
+    }
+
     /**
      * Extracts semantic elements from storage value.
      * For wrappers, extracts the .element; for arrays, returns array of elements.

package/src/javascript/templating/rewrite.ts

@@ -15,7 +15,7 @@
  */
 import {Cursor, ExecutionContext, Recipe} from '../..';
 import {J} from '../../java';
-import {RewriteRule, RewriteConfig} from './types';
+import {RewriteRule, RewriteConfig, PreMatchContext, PostMatchContext} from './types';
 import {Pattern, MatchResult} from './pattern';
 import {Template} from './template';
 
@@ -26,28 +26,29 @@ class RewriteRuleImpl implements RewriteRule {
     constructor(
         private readonly before: Pattern[],
         private readonly after: Template | ((match: MatchResult) => Template),
-        private readonly where?: (node: J, cursor: Cursor) => boolean | Promise<boolean>,
-        private readonly whereNot?: (node: J, cursor: Cursor) => boolean | Promise<boolean>
+        private readonly preMatch?: (node: J, context: PreMatchContext) => boolean | Promise<boolean>,
+        private readonly postMatch?: (node: J, context: PostMatchContext) => boolean | Promise<boolean>
     ) {
     }
 
     async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
+        // Evaluate preMatch before attempting any pattern matching
+        if (this.preMatch) {
+            const preMatchResult = await this.preMatch(node, { cursor });
+            if (!preMatchResult) {
+                return undefined; // Early exit - don't attempt pattern matching
+            }
+        }
+
         for (const pattern of this.before) {
             // Pass cursor to pattern.match() for context-aware capture constraints
             const match = await pattern.match(node, cursor);
             if (match) {
-                // Evaluate context predicates after structural match
-                if (this.where) {
-                    const whereResult = await this.where(node, cursor);
-                    if (!whereResult) {
-                        continue; // Pattern matched but context doesn't, try next pattern
-                    }
-                }
-
-                if (this.whereNot) {
-                    const whereNotResult = await this.whereNot(node, cursor);
-                    if (whereNotResult) {
-                        continue; // Pattern matched but context is excluded, try next pattern
+                // Evaluate postMatch after structural match succeeds
+                if (this.postMatch) {
+                    const postMatchResult = await this.postMatch(node, { cursor, captures: match });
+                    if (!postMatchResult) {
+                        continue; // Pattern matched but postMatch failed, try next pattern
                     }
                 }
 
@@ -69,7 +70,7 @@ class RewriteRuleImpl implements RewriteRule {
             }
         }
 
-        // Return undefined if no patterns match or all context checks failed
+        // Return undefined if no patterns match or all postMatch checks failed
         return undefined;
     }
 
@@ -168,8 +169,8 @@ export function rewrite(
     return new RewriteRuleImpl(
         Array.isArray(config.before) ? config.before : [config.before],
         config.after,
-        config.where,
-        config.whereNot
+        config.preMatch,
+        config.postMatch
     );
 }
 

package/src/javascript/templating/types.ts

@@ -590,6 +590,33 @@ export interface RewriteRule {
     orElse(alternative: RewriteRule): RewriteRule;
 }
 
+/**
+ * Context for preMatch predicate - only has cursor, no captures yet.
+ */
+export interface PreMatchContext {
+    /**
+     * The cursor pointing to the node being considered for matching.
+     * Allows navigating the AST (parent, root, etc.).
+     */
+    cursor: Cursor;
+}
+
+/**
+ * Context for postMatch predicate - has cursor and captured values.
+ */
+export interface PostMatchContext {
+    /**
+     * The cursor pointing to the matched node.
+     * Allows navigating the AST (parent, root, etc.).
+     */
+    cursor: Cursor;
+
+    /**
+     * Values captured during pattern matching.
+     */
+    captures: CaptureMap;
+}
+
 /**
  * Configuration for a replacement rule.
  */
@@ -598,55 +625,52 @@ export interface RewriteConfig {
     after: Template | ((match: MatchResult) => Template);
 
     /**
-     * Optional context predicate that must evaluate to true for the transformation to be applied.
-     * Evaluated after the pattern matches structurally but before applying the template.
-     * Provides access to both the matched node and the cursor for context inspection.
+     * Optional predicate evaluated BEFORE pattern matching.
+     * Use for efficient early filtering based on AST context when captures aren't needed.
+     * If this returns false, pattern matching is skipped entirely.
      *
-     * @param node The matched AST node
-     * @param cursor The cursor at the matched node, providing access to ancestors and context
-     * @returns true if the transformation should be applied, false otherwise
+     * @param node The AST node being considered for matching
+     * @param context Context providing cursor for AST navigation
+     * @returns true to proceed with pattern matching, false to skip this node
      *
      * @example
      * ```typescript
      * rewrite(() => ({
-     *     before: pattern`await ${_('promise')}`,
-     *     after: template`await ${_('promise')}.catch(handleError)`,
-     *     where: (node, cursor) => {
-     *         // Only apply inside async functions
-     *         const method = cursor.firstEnclosing((n: any): n is J.MethodDeclaration =>
-     *             n.kind === J.Kind.MethodDeclaration
-     *         );
-     *         return method?.modifiers.some(m => m.type === 'async') || false;
+     *     before: pattern`console.log(${_('msg')})`,
+     *     after: template`logger.info(${_('msg')})`,
+     *     preMatch: (node, {cursor}) => {
+     *         // Only attempt matching inside functions named 'handleError'
+     *         const method = cursor.firstEnclosing(isMethodDeclaration);
+     *         return method?.name.simpleName === 'handleError';
      *     }
      * }));
      * ```
      */
-    where?: (node: J, cursor: Cursor) => boolean | Promise<boolean>;
+    preMatch?: (node: J, context: PreMatchContext) => boolean | Promise<boolean>;
 
     /**
-     * Optional context predicate that must evaluate to false for the transformation to be applied.
-     * Evaluated after the pattern matches structurally but before applying the template.
-     * Provides access to both the matched node and the cursor for context inspection.
+     * Optional predicate evaluated AFTER pattern matching succeeds.
+     * Use when you need access to captured values to decide whether to apply the transformation.
+     * If this returns false, the transformation is not applied.
      *
      * @param node The matched AST node
-     * @param cursor The cursor at the matched node, providing access to ancestors and context
-     * @returns true if the transformation should NOT be applied, false if it should proceed
+     * @param context Context providing cursor for AST navigation and captured values
+     * @returns true to apply the transformation, false to skip
      *
      * @example
      * ```typescript
      * rewrite(() => ({
-     *     before: pattern`await ${_('promise')}`,
-     *     after: template`await ${_('promise')}.catch(handleError)`,
-     *     whereNot: (node, cursor) => {
-     *         // Don't apply inside try-catch blocks
-     *         return cursor.firstEnclosing((n: any): n is J.Try =>
-     *             n.kind === J.Kind.Try
-     *         ) !== undefined;
+     *     before: pattern`${_('a')} + ${_('b')}`,
+     *     after: template`${_('b')} + ${_('a')}`,
+     *     postMatch: (node, {cursor, captures}) => {
+     *         // Only swap if 'a' is a literal number
+     *         const a = captures.get('a');
+     *         return a?.kind === J.Kind.Literal && typeof a.value === 'number';
      *     }
      * }));
      * ```
      */
-    whereNot?: (node: J, cursor: Cursor) => boolean | Promise<boolean>;
+    postMatch?: (node: J, context: PostMatchContext) => boolean | Promise<boolean>;
 }
 
 /**
@@ -755,6 +779,14 @@ export interface MatchResult {
     get(capture: string): any;
 
     get<T>(capture: Capture<T>): T | undefined;
+
+    /**
+     * Checks if a capture has been matched.
+     *
+     * @param capture The capture name (string) or Capture object
+     * @returns true if the capture exists in the match result
+     */
+    has(capture: Capture | string): boolean;
 }
 
 /**

package/src/javascript/tree.ts

@@ -89,6 +89,7 @@ export namespace JS {
         PropertyAssignment: "org.openrewrite.javascript.tree.JS$PropertyAssignment",
         SatisfiesExpression: "org.openrewrite.javascript.tree.JS$SatisfiesExpression",
         ScopedVariableDeclarations: "org.openrewrite.javascript.tree.JS$ScopedVariableDeclarations",
+        Shebang: "org.openrewrite.javascript.tree.JS$Shebang",
         StatementExpression: "org.openrewrite.javascript.tree.JS$StatementExpression",
         TaggedTemplateExpression: "org.openrewrite.javascript.tree.JS$TaggedTemplateExpression",
         TemplateExpression: "org.openrewrite.javascript.tree.JS$TemplateExpression",
@@ -449,6 +450,15 @@ export namespace JS {
         readonly variables: J.RightPadded<J>[];
     }
 
+    /**
+     * Represents a shebang line at the beginning of a script.
+     * @example #!/usr/bin/env node
+     */
+    export interface Shebang extends JS, Statement {
+        readonly kind: typeof Kind.Shebang;
+        readonly text: string;
+    }
+
     /**
      * Represents a statement used as an expression. The example shows a function expressions.
      * @example const greet = function  (name: string) : string { return name; };

package/src/javascript/type-mapping.ts

@@ -65,6 +65,16 @@ export class JavaScriptTypeMapping {
     }
 
     type(node: ts.Node): Type | undefined {
+        // For identifiers, check if this references a variable
+        // This enables fieldType attribution for variable references
+        if (ts.isIdentifier(node)) {
+            const variableType = this.variableType(node);
+            if (variableType) {
+                return variableType;
+            }
+            // Fall through to regular type checking if not a variable
+        }
+
         let type: ts.Type | undefined;
         if (ts.isExpression(node)) {
             type = this.checker.getTypeAtLocation(node);
@@ -115,6 +125,14 @@ export class JavaScriptTypeMapping {
             return existing;
         }
 
+        // TypeScript represents `boolean` as a union of `false | true`, but the union
+        // type still has the Boolean flag set. Check this early to return Primitive.Boolean
+        // before we process it as a generic union type.
+        if (type.flags & ts.TypeFlags.Boolean) {
+            this.typeCache.set(signature, Type.Primitive.Boolean);
+            return Type.Primitive.Boolean;
+        }
+
         // Get symbol for later use in type detection
         const symbol = type.getSymbol?.();
 
@@ -248,8 +266,7 @@ export class JavaScriptTypeMapping {
 
         // Check for union types (e.g., string | number)
         if (type.flags & ts.TypeFlags.Union) {
-            const unionType = type as ts.UnionType;
-            return this.createUnionType(unionType, signature);
+            return this.createUnionType(type as ts.UnionType, signature);
         }
 
         // Check for intersection types (e.g., A & B)
@@ -318,16 +335,229 @@ export class JavaScriptTypeMapping {
         return Type.isPrimitive(type) ? type : Type.Primitive.None;
     }
 
-    variableType(node: ts.NamedDeclaration): Type.Variable | undefined {
+    variableType(node: ts.Node): Type.Variable | undefined {
+        let symbol: ts.Symbol | undefined;
+        let location: ts.Node = node;
+
+        // Get the symbol depending on node type
         if (ts.isVariableDeclaration(node)) {
-            const symbol = this.checker.getSymbolAtLocation(node.name);
-            if (symbol) {
-                // TODO: Implement in Phase 6
-                // const type = this.checker.getTypeOfSymbolAtLocation(symbol, node);
-                // return JavaType.Variable with proper mapping
+            symbol = this.checker.getSymbolAtLocation(node.name);
+        } else if (ts.isParameter(node)) {
+            symbol = this.checker.getSymbolAtLocation(node.name);
+        } else if (ts.isIdentifier(node)) {
+            // For identifier references (like 'vi' in 'vi.fn()')
+            symbol = this.checker.getSymbolAtLocation(node);
+        } else if (ts.isPropertyDeclaration(node) || ts.isPropertySignature(node)) {
+            symbol = this.checker.getSymbolAtLocation(node.name);
+        } else {
+            // Not a variable/parameter/property we can handle
+            return undefined;
+        }
+
+        if (!symbol) {
+            return undefined;
+        }
+
+        // Get the variable declaration (resolve aliases if needed)
+        let actualSymbol = symbol;
+        if (symbol.flags & ts.SymbolFlags.Alias) {
+            actualSymbol = this.checker.getAliasedSymbol(symbol);
+        }
+
+        // Check if this symbol represents a variable, parameter, or property
+        // Exclude functions, classes, interfaces, namespaces, type aliases
+        const isExcluded = actualSymbol.flags & (
+            ts.SymbolFlags.Function |
+            ts.SymbolFlags.Class |
+            ts.SymbolFlags.Interface |
+            ts.SymbolFlags.Enum |
+            ts.SymbolFlags.ValueModule |
+            ts.SymbolFlags.NamespaceModule |
+            ts.SymbolFlags.TypeAlias |
+            ts.SymbolFlags.TypeParameter
+        );
+
+        if (isExcluded) {
+            // Not a variable - it's a type, function, class, namespace, etc.
+            return undefined;
+        }
+
+        const isVariable = actualSymbol.flags & (
+            ts.SymbolFlags.Variable |
+            ts.SymbolFlags.Property |
+            ts.SymbolFlags.FunctionScopedVariable |
+            ts.SymbolFlags.BlockScopedVariable
+        );
+
+        if (!isVariable) {
+            // Not a variable we recognize
+            return undefined;
+        }
+
+        // Get the type of the variable
+        const variableType = this.checker.getTypeOfSymbolAtLocation(actualSymbol, location);
+        const mappedType = this.getType(variableType);
+
+        // Get the owner (declaring type) for the variable
+        let ownerType: Type | undefined;
+
+        // Check if the variable is imported
+        if (symbol.flags & ts.SymbolFlags.Alias) {
+            // For imported variables, find the module specifier
+            const declarations = symbol.declarations;
+            if (declarations && declarations.length > 0) {
+                let importNode: ts.Node | undefined = declarations[0];
+
+                // Traverse up to find the ImportDeclaration
+                while (importNode && !ts.isImportDeclaration(importNode)) {
+                    importNode = importNode.parent;
+                }
+
+                if (importNode && ts.isImportDeclaration(importNode)) {
+                    const importDecl = importNode as ts.ImportDeclaration;
+                    if (ts.isStringLiteral(importDecl.moduleSpecifier)) {
+                        const moduleSpecifier = importDecl.moduleSpecifier.text;
+                        // Create a Type.Class representing the module
+                        ownerType = Object.assign(new NonDraftableType(), {
+                            kind: Type.Kind.Class,
+                            flags: 0,
+                            classKind: Type.Class.Kind.Interface,
+                            fullyQualifiedName: moduleSpecifier,
+                            typeParameters: [],
+                            annotations: [],
+                            interfaces: [],
+                            members: [],
+                            methods: [],
+                            toJSON: function () {
+                                return Type.signature(this);
+                            }
+                        }) as Type.Class;
+                    }
+                }
+            }
+        } else {
+            // For non-imported variables, check if they belong to a class/interface/namespace
+            const parentSymbol = (actualSymbol as any).parent as ts.Symbol | undefined;
+            if (parentSymbol) {
+                const parentType = this.checker.getDeclaredTypeOfSymbol(parentSymbol);
+                if (parentType) {
+                    ownerType = this.getType(parentType);
+
+                    // If the parent is a namespace, try to find the module it came from
+                    // This handles cases like React.forwardRef where the namespace is React
+                    // but the module is "react"
+                    if (parentSymbol.flags & ts.SymbolFlags.ValueModule ||
+                        parentSymbol.flags & ts.SymbolFlags.NamespaceModule) {
+                        // Check if this namespace was imported
+                        const parentDeclarations = parentSymbol.declarations;
+                        if (parentDeclarations && parentDeclarations.length > 0) {
+                            const firstDecl = parentDeclarations[0];
+                            const sourceFile = firstDecl.getSourceFile();
+                            // If it's from node_modules or a .d.ts file, try to extract the module name
+                            if (sourceFile.isDeclarationFile) {
+                                const fileName = sourceFile.fileName;
+                                const moduleName = this.extractModuleNameFromPath(fileName);
+                                if (moduleName) {
+                                    // Store the module as the owningClass for now
+                                    // (This is a bit of a hack, but works with the current type system)
+                                    if (Type.isClass(ownerType)) {
+                                        (ownerType as any).owningClass = Object.assign(new NonDraftableType(), {
+                                            kind: Type.Kind.Class,
+                                            flags: 0,
+                                            classKind: Type.Class.Kind.Interface,
+                                            fullyQualifiedName: moduleName,
+                                            typeParameters: [],
+                                            annotations: [],
+                                            interfaces: [],
+                                            members: [],
+                                            methods: [],
+                                            toJSON: function () {
+                                                return Type.signature(this);
+                                            }
+                                        }) as Type.Class;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
         }
-        return undefined;
+
+        // Create the Type.Variable
+        const variable = Object.assign(new NonDraftableType(), {
+            kind: Type.Kind.Variable,
+            name: actualSymbol.getName(),
+            owner: ownerType,
+            type: mappedType,
+            annotations: [],
+            toJSON: function () {
+                return Type.signature(this);
+            }
+        }) as Type.Variable;
+
+        return variable;
+    }
+
+    /**
+     * Extract the npm module name from a file path.
+     * Handles various package manager layouts:
+     * - Standard: /path/node_modules/react/index.d.ts -> react
+     * - Scoped: /path/node_modules/@types/react/index.d.ts -> react
+     * - Scoped with __ encoding: /path/node_modules/@types/testing-library__react/index.d.ts -> @testing-library/react
+     * - Nested node_modules: /path/node_modules/pkg/node_modules/dep/index.d.ts -> dep
+     * - pnpm: /path/node_modules/.pnpm/react@18.2.0/node_modules/react/index.d.ts -> react
+     *
+     * @returns The module name, or undefined if not from node_modules
+     */
+    private extractModuleNameFromPath(fileName: string): string | undefined {
+        if (!fileName.includes('node_modules/')) {
+            return undefined;
+        }
+
+        // Find the last occurrence of node_modules/ to handle nested dependencies
+        // This also correctly handles pnpm's .pnpm structure
+        const lastNodeModulesIndex = fileName.lastIndexOf('node_modules/');
+        const afterNodeModules = fileName.substring(lastNodeModulesIndex + 'node_modules/'.length);
+
+        // Split by '/' to get path segments
+        const segments = afterNodeModules.split('/');
+        if (segments.length === 0) {
+            return undefined;
+        }
+
+        let moduleName: string;
+
+        // Handle scoped packages (@scope/package)
+        if (segments[0].startsWith('@') && segments.length > 1) {
+            moduleName = `${segments[0]}/${segments[1]}`;
+        } else {
+            moduleName = segments[0];
+        }
+
+        // Skip pnpm's .pnpm directory - it contains versioned package paths
+        // In pnpm, the actual package is in: .pnpm/pkg@version/node_modules/pkg
+        // So we already handled this by using lastIndexOf above
+        if (moduleName === '.pnpm') {
+            return undefined;
+        }
+
+        // Remove @types/ prefix and decode DefinitelyTyped scoped package encoding
+        // DefinitelyTyped encodes scoped packages using __ instead of /
+        // Example: @types/testing-library__react -> @testing-library/react
+        if (moduleName.startsWith('@types/')) {
+            moduleName = moduleName.substring('@types/'.length);
+            // Decode __ encoding for scoped packages
+            // testing-library__react -> @testing-library/react
+            if (moduleName.includes('__')) {
+                const parts = moduleName.split('__');
+                if (parts.length === 2) {
+                    moduleName = `@${parts[0]}/${parts[1]}`;
+                }
+            }
+        }
+
+        return moduleName;
     }
 
     /**

package/src/javascript/visitor.ts

@@ -588,6 +588,14 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
         return updateIfChanged(scopedVariableDeclarations, updates);
     }
 
+    protected async visitShebang(shebang: JS.Shebang, p: P): Promise<J | undefined> {
+        const updates: any = {
+            prefix: await this.visitSpace(shebang.prefix, p),
+            markers: await this.visitMarkers(shebang.markers, p)
+        };
+        return updateIfChanged(shebang, updates);
+    }
+
     protected async visitStatementExpression(statementExpression: JS.StatementExpression, p: P): Promise<J | undefined> {
         const expression = await this.visitExpression(statementExpression, p);
         if (!expression?.kind || expression.kind !== JS.Kind.StatementExpression) {
@@ -1158,6 +1166,8 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
                     return this.visitSatisfiesExpression(tree as unknown as JS.SatisfiesExpression, p);
                 case JS.Kind.ScopedVariableDeclarations:
                     return this.visitScopedVariableDeclarations(tree as unknown as JS.ScopedVariableDeclarations, p);
+                case JS.Kind.Shebang:
+                    return this.visitShebang(tree as unknown as JS.Shebang, p);
                 case JS.Kind.StatementExpression:
                     return this.visitStatementExpression(tree as unknown as JS.StatementExpression, p);
                 case JS.Kind.TaggedTemplateExpression:

package/src/json/parser.ts

@@ -90,11 +90,25 @@ class ParseJsonReader extends ParserSourceReader {
                 })
             } satisfies Json.Object as Json.Object;
         } else if (typeof parsed === "string") {
-            this.cursor += parsed.length + 2;
+            // Extract original source to preserve escape sequences
+            const sourceStart = this.cursor;
+            this.cursor++; // skip opening quote
+            while (this.cursor < this.source.length) {
+                const char = this.source[this.cursor];
+                if (char === '\\') {
+                    this.cursor += 2; // skip escape sequence
+                } else if (char === '"') {
+                    this.cursor++; // skip closing quote
+                    break;
+                } else {
+                    this.cursor++;
+                }
+            }
+            const source = this.source.slice(sourceStart, this.cursor);
             return {
                 kind: Json.Kind.Literal,
                 ...base,
-                source: `"${parsed}"`,
+                source,
                 value: parsed
             } satisfies Json.Literal as Json.Literal;
         } else if (typeof parsed === "number") {