@esportsplus/reactivity 0.24.4 → 0.25.0

package/src/transformer/transforms/primitives.ts

@@ -1,16 +1,17 @@
-import { uid } from '@esportsplus/typescript/transformer';
-import type { BindingType, Bindings, Namespaces } from '~/types';
-import {
-    createCommaExpr,
-    createComputedCall,
-    createPostfixIncrementExpr,
-    createReadCall,
-    createSetCall,
-    createSignalCall
-} from '../factory';
+import { uid, type Range } from '@esportsplus/typescript/transformer';
+import type { BindingType, Bindings } from '~/types';
+import { addMissingImports, applyReplacements, Replacement } from './utilities';
 import { ts } from '@esportsplus/typescript';
 
 
+interface ArgContext {
+    argStart: number;
+    innerReplacements: Replacement[];
+    neededImports: Set<string>;
+    scopedBindings: ScopeBinding[];
+    sourceFile: ts.SourceFile;
+}
+
 interface ScopeBinding {
     name: string;
     scope: ts.Node;
@@ -19,12 +20,12 @@ interface ScopeBinding {
 
 interface TransformContext {
     bindings: Bindings;
-    context: ts.TransformationContext;
-    factory: ts.NodeFactory;
+    computedArgRanges: Range[];
     hasReactiveImport: boolean;
     neededImports: Set<string>;
-    ns: Namespaces;
+    replacements: Replacement[];
     scopedBindings: ScopeBinding[];
+    sourceFile: ts.SourceFile;
 }
 
 
@@ -57,14 +58,14 @@ function findEnclosingScope(node: ts.Node): ts.Node {
 
     while (current) {
         if (
-            ts.isArrowFunction(current) ||
             ts.isBlock(current) ||
-            ts.isForInStatement(current) ||
-            ts.isForOfStatement(current) ||
-            ts.isForStatement(current) ||
+            ts.isSourceFile(current) ||
             ts.isFunctionDeclaration(current) ||
             ts.isFunctionExpression(current) ||
-            ts.isSourceFile(current)
+            ts.isArrowFunction(current) ||
+            ts.isForStatement(current) ||
+            ts.isForInStatement(current) ||
+            ts.isForOfStatement(current)
         ) {
             return current;
         }
@@ -75,82 +76,70 @@ function findEnclosingScope(node: ts.Node): ts.Node {
     return node.getSourceFile();
 }
 
-function getCompoundOperator(kind: ts.SyntaxKind): ts.BinaryOperator {
+function getCompoundOperator(kind: ts.SyntaxKind): string {
     if (kind === ts.SyntaxKind.PlusEqualsToken) {
-        return ts.SyntaxKind.PlusToken;
+        return '+';
     }
     else if (kind === ts.SyntaxKind.MinusEqualsToken) {
-        return ts.SyntaxKind.MinusToken;
+        return '-';
     }
     else if (kind === ts.SyntaxKind.AsteriskEqualsToken) {
-        return ts.SyntaxKind.AsteriskToken;
+        return '*';
     }
     else if (kind === ts.SyntaxKind.SlashEqualsToken) {
-        return ts.SyntaxKind.SlashToken;
+        return '/';
     }
     else if (kind === ts.SyntaxKind.PercentEqualsToken) {
-        return ts.SyntaxKind.PercentToken;
+        return '%';
     }
     else if (kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
-        return ts.SyntaxKind.AsteriskAsteriskToken;
+        return '**';
     }
     else if (kind === ts.SyntaxKind.AmpersandEqualsToken) {
-        return ts.SyntaxKind.AmpersandToken;
+        return '&';
     }
     else if (kind === ts.SyntaxKind.BarEqualsToken) {
-        return ts.SyntaxKind.BarToken;
+        return '|';
     }
     else if (kind === ts.SyntaxKind.CaretEqualsToken) {
-        return ts.SyntaxKind.CaretToken;
+        return '^';
     }
     else if (kind === ts.SyntaxKind.LessThanLessThanEqualsToken) {
-        return ts.SyntaxKind.LessThanLessThanToken;
+        return '<<';
     }
     else if (kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken) {
-        return ts.SyntaxKind.GreaterThanGreaterThanToken;
+        return '>>';
     }
     else if (kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
-        return ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
+        return '>>>';
     }
     else if (kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
-        return ts.SyntaxKind.AmpersandAmpersandToken;
+        return '&&';
     }
     else if (kind === ts.SyntaxKind.BarBarEqualsToken) {
-        return ts.SyntaxKind.BarBarToken;
+        return '||';
     }
     else if (kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-        return ts.SyntaxKind.QuestionQuestionToken;
+        return '??';
     }
     else {
-        return ts.SyntaxKind.PlusToken;
+        return '+';
     }
 }
 
-function isAssignmentOperator(kind: ts.SyntaxKind): 'compound' | 'simple' | false {
-    if (kind === ts.SyntaxKind.EqualsToken) {
-        return 'simple';
-    }
-
-    if (kind >= ts.SyntaxKind.PlusEqualsToken && kind <= ts.SyntaxKind.CaretEqualsToken) {
-        return 'compound';
-    }
+function isInComputedRange(ranges: Range[], start: number, end: number): boolean {
+    for (let i = 0, n = ranges.length; i < n; i++) {
+        let r = ranges[i];
 
-    if (
-        kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
-        kind === ts.SyntaxKind.BarBarEqualsToken ||
-        kind === ts.SyntaxKind.QuestionQuestionEqualsToken
-    ) {
-        return 'compound';
+        if (start >= r.start && end <= r.end) {
+            return true;
+        }
     }
 
     return false;
 }
 
-function isInDeclarationInit(node: ts.Node | undefined): boolean {
-    if (!node || !node.parent) {
-        return false;
-    }
-
+function isInDeclarationInit(node: ts.Node): boolean {
     let parent = node.parent;
 
     if (ts.isVariableDeclaration(parent) && parent.initializer === node) {
@@ -174,13 +163,16 @@ function isInScope(reference: ts.Node, binding: ScopeBinding): boolean {
     return false;
 }
 
-function isReactiveReassignment(node: ts.BinaryExpression): boolean {
-    let right = node.right;
+function isReactiveReassignment(node: ts.Node): boolean {
+    let parent = node.parent;
 
     if (
-        ts.isCallExpression(right) &&
-        ts.isIdentifier(right.expression) &&
-        right.expression.text === 'reactive'
+        ts.isBinaryExpression(parent) &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        parent.right === node &&
+        ts.isCallExpression(node) &&
+        ts.isIdentifier((node as ts.CallExpression).expression) &&
+        ((node as ts.CallExpression).expression as ts.Identifier).text === 'reactive'
     ) {
         return true;
     }
@@ -188,8 +180,41 @@ function isReactiveReassignment(node: ts.BinaryExpression): boolean {
     return false;
 }
 
-function visit(ctx: TransformContext, node: ts.Node): ts.Node {
-    // Check for reactive import
+function isWriteContext(node: ts.Identifier): 'simple' | 'compound' | 'increment' | false {
+    let parent = node.parent;
+
+    if (ts.isBinaryExpression(parent) && parent.left === node) {
+        let op = parent.operatorToken.kind;
+
+        if (op === ts.SyntaxKind.EqualsToken) {
+            return 'simple';
+        }
+
+        if (op >= ts.SyntaxKind.PlusEqualsToken && op <= ts.SyntaxKind.CaretEqualsToken) {
+            return 'compound';
+        }
+
+        if (
+            op === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
+            op === ts.SyntaxKind.BarBarEqualsToken ||
+            op === ts.SyntaxKind.QuestionQuestionEqualsToken
+        ) {
+            return 'compound';
+        }
+    }
+
+    if (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) {
+        let op = parent.operator;
+
+        if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
+            return 'increment';
+        }
+    }
+
+    return false;
+}
+
+function visit(ctx: TransformContext, node: ts.Node): void {
     if (
         ts.isImportDeclaration(node) &&
         ts.isStringLiteral(node.moduleSpecifier) &&
@@ -207,7 +232,6 @@ function visit(ctx: TransformContext, node: ts.Node): ts.Node {
         }
     }
 
-    // Transform reactive() calls to signal() or computed()
     if (
         ctx.hasReactiveImport &&
         ts.isCallExpression(node) &&
@@ -221,11 +245,10 @@ function visit(ctx: TransformContext, node: ts.Node): ts.Node {
         if (classification) {
             let varName: string | null = null;
 
-            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+            if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varName = node.parent.name.text;
             }
             else if (
-                node.parent &&
                 ts.isBinaryExpression(node.parent) &&
                 node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
                 ts.isIdentifier(node.parent.left)
@@ -236,184 +259,155 @@ function visit(ctx: TransformContext, node: ts.Node): ts.Node {
             if (varName) {
                 let scope = findEnclosingScope(node);
 
-                ctx.bindings.set(varName, classification);
                 ctx.scopedBindings.push({ name: varName, scope, type: classification });
+                ctx.bindings.set(varName, classification);
             }
 
             if (classification === 'computed') {
-                ctx.neededImports.add('computed');
+                ctx.computedArgRanges.push({
+                    end: arg.end,
+                    start: arg.getStart(ctx.sourceFile)
+                });
 
-                // Transform the function body to wrap reactive reads
-                let transformedArg = ts.visitEachChild(arg, n => visitComputedArg(ctx, n), ctx.context);
+                let argCtx: ArgContext = {
+                    argStart: arg.getStart(ctx.sourceFile),
+                    innerReplacements: [],
+                    neededImports: ctx.neededImports,
+                    scopedBindings: ctx.scopedBindings,
+                    sourceFile: ctx.sourceFile
+                };
 
-                return createComputedCall(ctx.factory, ctx.ns.reactivity, transformedArg as ts.Expression);
-            }
-            else {
-                ctx.neededImports.add('signal');
+                visitArg(argCtx, arg);
 
-                return createSignalCall(ctx.factory, ctx.ns.reactivity, arg);
-            }
-        }
-    }
-
-    // Handle binary expressions (assignments) with reactive left side
-    if (ts.isBinaryExpression(node) && ts.isIdentifier(node.left)) {
-        let assignType = isAssignmentOperator(node.operatorToken.kind);
-
-        if (assignType) {
-            let binding = findBinding(ctx.scopedBindings, node.left.text, node.left);
-
-            if (binding && binding.type !== 'computed' && !isReactiveReassignment(node)) {
-                ctx.neededImports.add('set');
+                let argText = applyReplacements(arg.getText(ctx.sourceFile), argCtx.innerReplacements);
 
-                let factory = ctx.factory,
-                    name = node.left.text,
-                    signalIdent = factory.createIdentifier(name),
-                    transformedRight = ts.visitEachChild(node.right, n => visit(ctx, n), ctx.context) as ts.Expression;
+                ctx.replacements.push({
+                    end: node.end,
+                    newText: `computed(${argText})`,
+                    start: node.pos
+                });
 
-                if (assignType === 'simple') {
-                    // x = value → ns.set(x, value)
-                    return createSetCall(factory, ctx.ns.reactivity, signalIdent, transformedRight);
-                }
-                else {
-                    // x += value → ns.set(x, x.value + value)
-                    let op = getCompoundOperator(node.operatorToken.kind),
-                        valueAccess = factory.createPropertyAccessExpression(signalIdent, 'value');
-
-                    return createSetCall(
-                        factory,
-                        ctx.ns.reactivity,
-                        signalIdent,
-                        factory.createBinaryExpression(valueAccess, op, transformedRight)
-                    );
-                }
-            }
-        }
-    }
-
-    // Handle prefix unary expressions (++x, --x) with reactive operand
-    if (ts.isPrefixUnaryExpression(node) && ts.isIdentifier(node.operand)) {
-        let op = node.operator;
-
-        if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
-            let binding = findBinding(ctx.scopedBindings, node.operand.text, node.operand);
-
-            if (binding && binding.type !== 'computed') {
-                ctx.neededImports.add('set');
-
-                let delta = op === ts.SyntaxKind.PlusPlusToken ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken,
-                    factory = ctx.factory,
-                    name = node.operand.text,
-                    signalIdent = factory.createIdentifier(name),
-                    valueAccess = factory.createPropertyAccessExpression(signalIdent, 'value');
-
-                if (node.parent && ts.isExpressionStatement(node.parent)) {
-                    // ++x as statement → ns.set(x, x.value + 1)
-                    return createSetCall(
-                        factory,
-                        ctx.ns.reactivity,
-                        signalIdent,
-                        factory.createBinaryExpression(valueAccess, delta, factory.createNumericLiteral(1))
-                    );
-                }
-                else {
-                    // ++x in expression → (ns.set(x, x.value + 1), x.value)
-                    return createCommaExpr(
-                        factory,
-                        createSetCall(
-                            factory,
-                            ctx.ns.reactivity,
-                            signalIdent,
-                            factory.createBinaryExpression(valueAccess, delta, factory.createNumericLiteral(1))
-                        ),
-                        factory.createPropertyAccessExpression(factory.createIdentifier(name), 'value')
-                    );
-                }
+                ctx.neededImports.add('computed');
             }
-        }
-    }
+            else {
+                let argText = arg.getText(ctx.sourceFile);
 
-    // Handle postfix unary expressions (x++, x--) with reactive operand
-    if (ts.isPostfixUnaryExpression(node) && ts.isIdentifier(node.operand)) {
-        let op = node.operator;
+                ctx.replacements.push({
+                    end: node.end,
+                    newText: `signal(${argText})`,
+                    start: node.pos
+                });
 
-        if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
-            let binding = findBinding(ctx.scopedBindings, node.operand.text, node.operand);
-
-            if (binding && binding.type !== 'computed') {
-                ctx.neededImports.add('set');
-
-                let delta = op === ts.SyntaxKind.PlusPlusToken ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken,
-                    factory = ctx.factory,
-                    name = node.operand.text,
-                    signalIdent = factory.createIdentifier(name),
-                    valueAccess = factory.createPropertyAccessExpression(signalIdent, 'value');
-
-                if (node.parent && ts.isExpressionStatement(node.parent)) {
-                    // x++ as statement → ns.set(x, x.value + 1)
-                    return createSetCall(
-                        factory,
-                        ctx.ns.reactivity,
-                        signalIdent,
-                        factory.createBinaryExpression(valueAccess, delta, factory.createNumericLiteral(1))
-                    );
-                }
-                else {
-                    // x++ in expression → ((tmp) => (ns.set(x, tmp + 1), tmp))(x.value)
-                    return createPostfixIncrementExpr(factory, ctx.ns.reactivity, uid('tmp'), name, delta);
-                }
+                ctx.neededImports.add('signal');
             }
         }
     }
 
-    // Handle reactive variable reads (not in write context)
-    if (ts.isIdentifier(node) && node.parent && !isInDeclarationInit(node.parent)) {
-        // Skip property names in property access expressions
+    if (ts.isIdentifier(node) && !isInDeclarationInit(node.parent)) {
         if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
-        }
-
-        // Skip if this identifier is the left side of an assignment (handled above)
-        if (ts.isBinaryExpression(node.parent) && node.parent.left === node) {
-            return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+            ts.forEachChild(node, n => visit(ctx, n));
+            return;
         }
 
-        // Skip if this is the operand of a unary expression (handled above)
-        if (
-            (ts.isPrefixUnaryExpression(node.parent) || ts.isPostfixUnaryExpression(node.parent)) &&
-            node.parent.operand === node
-        ) {
-            return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
-        }
+        let nodeStart = node.getStart(ctx.sourceFile);
 
-        // Skip typeof checks
-        if (ts.isTypeOfExpression(node.parent) && node.parent.expression === node) {
-            return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+        if (isInComputedRange(ctx.computedArgRanges, nodeStart, node.end)) {
+            ts.forEachChild(node, n => visit(ctx, n));
+            return;
         }
 
-        let binding = findBinding(ctx.scopedBindings, node.text, node);
+        let binding = findBinding(ctx.scopedBindings, node.text, node),
+            name = node.text;
 
         if (binding) {
-            // Read access → ns.read(x)
-            ctx.neededImports.add('read');
+            if (
+                !isReactiveReassignment(node.parent) &&
+                !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)
+            ) {
+                let writeCtx = isWriteContext(node);
+
+                if (writeCtx) {
+                    if (binding.type !== 'computed') {
+                        ctx.neededImports.add('set');
+
+                        let parent = node.parent;
+
+                        if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
+                            let valueText = parent.right.getText(ctx.sourceFile);
+
+                            ctx.replacements.push({
+                                end: parent.end,
+                                newText: `set(${name}, ${valueText})`,
+                                start: parent.pos
+                            });
+                        }
+                        else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
+                            let op = getCompoundOperator(parent.operatorToken.kind),
+                                valueText = parent.right.getText(ctx.sourceFile);
+
+                            ctx.replacements.push({
+                                end: parent.end,
+                                newText: `set(${name}, ${name}.value ${op} ${valueText})`,
+                                start: parent.pos
+                            });
+                        }
+                        else if (writeCtx === 'increment') {
+                            let isPrefix = ts.isPrefixUnaryExpression(parent),
+                                op = (parent as ts.PrefixUnaryExpression | ts.PostfixUnaryExpression).operator,
+                                delta = op === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1';
+
+                            if (ts.isExpressionStatement(parent.parent)) {
+                                ctx.replacements.push({
+                                    end: parent.end,
+                                    newText: `set(${name}, ${name}.value ${delta})`,
+                                    start: parent.pos
+                                });
+                            }
+                            else if (isPrefix) {
+                                ctx.replacements.push({
+                                    end: parent.end,
+                                    newText: `(set(${name}, ${name}.value ${delta}), ${name}.value)`,
+                                    start: parent.pos
+                                });
+                            }
+                            else {
+                                let tmp = uid('tmp');
+
+                                ctx.replacements.push({
+                                    end: parent.end,
+                                    newText: `((${tmp}) => (set(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
+                                    start: parent.pos
+                                });
+                            }
+                        }
+                    }
+                }
+                else {
+                    ctx.neededImports.add('read');
 
-            return createReadCall(ctx.factory, ctx.ns.reactivity, ctx.factory.createIdentifier(node.text));
+                    ctx.replacements.push({
+                        end: node.end,
+                        newText: `read(${name})`,
+                        start: node.pos
+                    });
+                }
+            }
         }
     }
 
-    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+    ts.forEachChild(node, n => visit(ctx, n));
 }
 
-function visitComputedArg(ctx: TransformContext, node: ts.Node): ts.Node {
-    // Skip property names in property access
-    if (ts.isIdentifier(node) && node.parent) {
+function visitArg(ctx: ArgContext, node: ts.Node): void {
+    if (ts.isIdentifier(node)) {
         if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            return ts.visitEachChild(node, n => visitComputedArg(ctx, n), ctx.context);
+            ts.forEachChild(node, n => visitArg(ctx, n));
+            return;
         }
 
-        // Skip function call expressions
         if (ts.isCallExpression(node.parent) && node.parent.expression === node) {
-            return ts.visitEachChild(node, n => visitComputedArg(ctx, n), ctx.context);
+            ts.forEachChild(node, n => visitArg(ctx, n));
+            return;
         }
 
         let binding = findBinding(ctx.scopedBindings, node.text, node);
@@ -421,35 +415,47 @@ function visitComputedArg(ctx: TransformContext, node: ts.Node): ts.Node {
         if (binding) {
             ctx.neededImports.add('read');
 
-            return createReadCall(ctx.factory, ctx.ns.reactivity, ctx.factory.createIdentifier(node.text));
+            ctx.innerReplacements.push({
+                end: node.end - ctx.argStart,
+                newText: `read(${node.text})`,
+                start: node.getStart(ctx.sourceFile) - ctx.argStart
+            });
         }
     }
 
-    return ts.visitEachChild(node, n => visitComputedArg(ctx, n), ctx.context);
+    ts.forEachChild(node, n => visitArg(ctx, n));
 }
 
 
-const createPrimitivesTransformer = (
-    bindings: Bindings,
-    neededImports: Set<string>,
-    ns: Namespaces
-): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile => {
-    return (context: ts.TransformationContext) => {
-        return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            let ctx: TransformContext = {
-                bindings,
-                context,
-                factory: context.factory,
-                hasReactiveImport: false,
-                neededImports,
-                ns,
-                scopedBindings: []
-            };
-
-            return ts.visitNode(sourceFile, n => visit(ctx, n)) as ts.SourceFile;
+const transformReactivePrimitives = (
+    sourceFile: ts.SourceFile,
+    bindings: Bindings
+): string => {
+    let code = sourceFile.getFullText(),
+        ctx: TransformContext = {
+            bindings,
+            computedArgRanges: [],
+            hasReactiveImport: false,
+            neededImports: new Set<string>(),
+            replacements: [],
+            scopedBindings: [],
+            sourceFile
         };
-    };
+
+    visit(ctx, sourceFile);
+
+    if (ctx.replacements.length === 0) {
+        return code;
+    }
+
+    let result = applyReplacements(code, ctx.replacements);
+
+    if (ctx.neededImports.size > 0) {
+        result = addMissingImports(result, ctx.neededImports);
+    }
+
+    return result;
 };
 
 
-export { createPrimitivesTransformer };
+export { transformReactivePrimitives };

package/src/transformer/transforms/utilities.ts

@@ -0,0 +1,45 @@
+import { addImport, applyReplacements, type Replacement } from '@esportsplus/typescript/transformer';
+
+
+type ExtraImport = {
+    module: string;
+    specifier: string;
+};
+
+
+const addMissingImports = (code: string, needed: Set<string>, extraImports?: ExtraImport[]): string => {
+    let extraSpecifiers = new Set<string>(),
+        reactivitySpecifiers: string[] = [];
+
+    if (extraImports) {
+        for (let i = 0, n = extraImports.length; i < n; i++) {
+            extraSpecifiers.add(extraImports[i].specifier);
+        }
+    }
+
+    for (let imp of needed) {
+        if (!extraSpecifiers.has(imp)) {
+            reactivitySpecifiers.push(imp);
+        }
+    }
+
+    if (reactivitySpecifiers.length > 0) {
+        code = addImport(code, '@esportsplus/reactivity', reactivitySpecifiers);
+    }
+
+    if (extraImports) {
+        for (let i = 0, n = extraImports.length; i < n; i++) {
+            let extra = extraImports[i];
+
+            if (needed.has(extra.specifier)) {
+                code = addImport(code, extra.module, [extra.specifier]);
+            }
+        }
+    }
+
+    return code;
+};
+
+
+export { addMissingImports, applyReplacements };
+export type { ExtraImport, Replacement };