@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/remodule.js

@@ -0,0 +1,620 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remoduleTransformer = remoduleTransformer;
+// src/transformers/remodule.ts
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("./utils");
+function remoduleTransformer(program) {
+    const typeChecker = program.getTypeChecker();
+    return (context) => {
+        return (sourceFile) => {
+            const factory = context.factory;
+            let currentScope = null;
+            let scopeIdCounter = 0;
+            const scopeToId = new WeakMap();
+            const variableUsages = new Map(); // "scopeId:varName" -> usage info
+            function getUsageKey(scopeId, varName) {
+                return `${scopeId}:${varName}`;
+            }
+            // Проверяет, является ли импорт только типом (type, interface, etc.)
+            function isTypeOnlyImport(node) {
+                let symbol = typeChecker.getSymbolAtLocation(node);
+                if (!symbol) {
+                    return false;
+                }
+                // Получаем алиасированный символ (если это импорт)
+                if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+                    symbol = typeChecker.getAliasedSymbol(symbol);
+                }
+                // Если у символа нет деклараций, считаем что это не тип
+                if (!symbol.declarations || symbol.declarations.length === 0) {
+                    return false;
+                }
+                // Проверяем все декларации символа
+                return symbol.declarations.every(decl => {
+                    return typescript_1.default.isTypeAliasDeclaration(decl) ||
+                        typescript_1.default.isInterfaceDeclaration(decl) ||
+                        typescript_1.default.isTypeParameterDeclaration(decl);
+                });
+            }
+            // Добавляем var __module_env = {}; в начало файла
+            const moduleEnvDecl = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration('__module_env', undefined, undefined, factory.createObjectLiteralExpression([], false))], typescript_1.default.NodeFlags.None));
+            function createScope(envName) {
+                const scope = {
+                    parent: currentScope,
+                    declarations: new Set(),
+                    envName
+                };
+                scopeToId.set(scope, `scope_${scopeIdCounter++}`);
+                return scope;
+            }
+            function getScopeId(scope) {
+                return scopeToId.get(scope) || 'unknown';
+            }
+            function addDeclaration(name, isFunction = false) {
+                if (currentScope) {
+                    currentScope.declarations.add(name);
+                    const scopeId = getScopeId(currentScope);
+                    const key = getUsageKey(scopeId, name);
+                    // Инициализируем информацию об использовании только если еще не было
+                    if (!variableUsages.has(key)) {
+                        variableUsages.set(key, {
+                            declaredInScope: scopeId,
+                            usedInScopes: new Set(),
+                            isFunction
+                        });
+                    }
+                }
+            }
+            function recordUsage(name) {
+                if (currentScope) {
+                    // Находим, где объявлена эта переменная
+                    let scope = currentScope;
+                    while (scope) {
+                        if (scope.declarations.has(name)) {
+                            const declScopeId = getScopeId(scope);
+                            const key = getUsageKey(declScopeId, name);
+                            const usage = variableUsages.get(key);
+                            if (usage) {
+                                const currentScopeId = getScopeId(currentScope);
+                                usage.usedInScopes.add(currentScopeId);
+                            }
+                            return;
+                        }
+                        scope = scope.parent;
+                    }
+                }
+            }
+            function isUsedInDifferentScope(varName) {
+                // Находим, где объявлена эта переменная
+                let scope = currentScope;
+                while (scope) {
+                    if (scope.declarations.has(varName)) {
+                        const declScopeId = getScopeId(scope);
+                        const key = getUsageKey(declScopeId, varName);
+                        const usage = variableUsages.get(key);
+                        if (!usage)
+                            return false;
+                        // Проверяем, используется ли переменная в scope'е, отличном от того где объявлена
+                        for (const scopeId of usage.usedInScopes) {
+                            if (scopeId !== usage.declaredInScope) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    }
+                    scope = scope.parent;
+                }
+                return false;
+            }
+            function findDeclaration(name) {
+                let scope = currentScope;
+                let depth = 0;
+                while (scope) {
+                    if (scope.declarations.has(name)) {
+                        // Строим путь к переменной
+                        if (depth === 0) {
+                            return { envPath: `__env.${name}`, found: true };
+                        }
+                        let path = '__env';
+                        for (let i = 0; i < depth; i++) {
+                            path += '.__parent';
+                        }
+                        path += '.' + name;
+                        return { envPath: path, found: true };
+                    }
+                    scope = scope.parent;
+                    depth++;
+                }
+                return { envPath: name, found: false };
+            }
+            function parseEnvPath(envPath) {
+                const parts = envPath.split('.');
+                let expr = factory.createIdentifier(parts[0]);
+                for (let i = 1; i < parts.length; i++) {
+                    expr = factory.createPropertyAccessExpression(expr, parts[i]);
+                }
+                return expr;
+            }
+            function createFunctionDescriptor(funcName, parentEnvName, isExported = false) {
+                const envName = `${funcName}__env`;
+                const descName = `${funcName}__desc`;
+                const statements = [];
+                // var funcName__env = { __parent: parentEnv };
+                statements.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(envName, undefined, undefined, factory.createObjectLiteralExpression([
+                        factory.createPropertyAssignment('__parent', factory.createIdentifier(parentEnvName))
+                    ], false))], typescript_1.default.NodeFlags.None)));
+                // var funcName__desc = { "@descriptor": "function", "obj": undefined, "env": funcName__env, "callable": funcName };
+                statements.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(descName, undefined, undefined, factory.createObjectLiteralExpression([
+                        factory.createPropertyAssignment(factory.createStringLiteral('@descriptor'), factory.createStringLiteral('function')),
+                        factory.createPropertyAssignment(factory.createStringLiteral('obj'), factory.createIdentifier('undefined')),
+                        factory.createPropertyAssignment(factory.createStringLiteral('env'), factory.createIdentifier(envName)),
+                        factory.createPropertyAssignment(factory.createStringLiteral('callable'), factory.createIdentifier(funcName))
+                    ], true))], typescript_1.default.NodeFlags.None)));
+                // parentEnv.funcName = funcName__desc
+                statements.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(factory.createIdentifier(parentEnvName)), funcName), factory.createIdentifier(descName))));
+                // Если экспортируется, добавляем __module.exports.funcName = funcName__desc
+                if (isExported) {
+                    const moduleExportPropertyAccessExpression = factory.createPropertyAccessExpression(factory.createIdentifier('__module'), 'exports');
+                    statements.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(moduleExportPropertyAccessExpression), funcName), factory.createIdentifier(descName))));
+                }
+                return statements;
+            }
+            function createVariableEnvAssignment(varName, parentEnvName) {
+                // parentEnv.varName = varName
+                return factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier(parentEnvName), varName), factory.createIdentifier(varName)));
+            }
+            // Сначала собираем все декларации в области видимости
+            function collectDeclarations(statements) {
+                for (const stmt of statements) {
+                    if (typescript_1.default.isFunctionDeclaration(stmt) && stmt.name) {
+                        addDeclaration(stmt.name.text, true); // функция
+                    }
+                    else if (typescript_1.default.isVariableStatement(stmt)) {
+                        for (const decl of stmt.declarationList.declarations) {
+                            if (typescript_1.default.isIdentifier(decl.name)) {
+                                addDeclaration(decl.name.text, false); // переменная
+                            }
+                        }
+                    }
+                }
+            }
+            // Первый проход: собираем информацию об использовании переменных
+            function analyzeUsages(node) {
+                if (typescript_1.default.isFunctionDeclaration(node) && node.name) {
+                    const savedScope = currentScope;
+                    currentScope = createScope('__env');
+                    if (node.body) {
+                        collectDeclarations(node.body.statements);
+                        for (const stmt of node.body.statements) {
+                            analyzeUsages(stmt);
+                        }
+                        // Также анализируем тело функции для использования переменных
+                        analyzeUsagesInExpression(node.body);
+                    }
+                    currentScope = savedScope;
+                    return;
+                }
+                if (typescript_1.default.isVariableStatement(node)) {
+                    // Проверяем initializer для использования переменных
+                    for (const decl of node.declarationList.declarations) {
+                        if (decl.initializer) {
+                            analyzeUsagesInExpression(decl.initializer);
+                        }
+                    }
+                    return;
+                }
+                typescript_1.default.forEachChild(node, analyzeUsages);
+            }
+            function analyzeUsagesInExpression(node) {
+                if (typescript_1.default.isIdentifier(node) && node.parent) {
+                    // Не считаем декларации и property names
+                    if (!typescript_1.default.isVariableDeclaration(node.parent) &&
+                        !typescript_1.default.isFunctionDeclaration(node.parent) &&
+                        !typescript_1.default.isParameter(node.parent) &&
+                        !(typescript_1.default.isPropertyAccessExpression(node.parent) && node.parent.name === node) &&
+                        !(typescript_1.default.isPropertyAssignment(node.parent) && node.parent.name === node) &&
+                        !(typescript_1.default.isBindingElement(node.parent) && node.parent.name === node)) {
+                        recordUsage(node.text);
+                    }
+                }
+                typescript_1.default.forEachChild(node, analyzeUsagesInExpression);
+            }
+            function transformFunctionBody(body, funcName) {
+                if (!body)
+                    return { body, envAssignments: [] };
+                const savedScope = currentScope;
+                currentScope = createScope('__env');
+                // Собираем все декларации в теле функции
+                collectDeclarations(body.statements);
+                const envAssignments = [];
+                const visitor = (node) => {
+                    // Заменяем this на __this
+                    if (node.kind === typescript_1.default.SyntaxKind.ThisKeyword) {
+                        return (0, utils_1.setParentNodes)(factory.createIdentifier('__this'), node.parent);
+                    }
+                    // Обрабатываем идентификаторы (доступ к переменным)
+                    if (typescript_1.default.isIdentifier(node) && node.parent && currentScope) {
+                        // Не трогаем: объявления переменных, имена функций при декларации, property access справа, параметры
+                        // Для PropertyAssignment проверяем, что это имя свойства (name), а не значение (initializer)
+                        if ((typescript_1.default.isVariableDeclaration(node.parent) && node.parent.name === node) ||
+                            typescript_1.default.isFunctionDeclaration(node.parent) ||
+                            typescript_1.default.isParameter(node.parent) ||
+                            (typescript_1.default.isPropertyAccessExpression(node.parent) && node.parent.name === node) ||
+                            (typescript_1.default.isPropertyAssignment(node.parent) && node.parent.name === node && node !== node.parent.initializer) ||
+                            (typescript_1.default.isBindingElement(node.parent) && node.parent.name === node)) {
+                            return node;
+                        }
+                        const { envPath, found } = findDeclaration(node.text);
+                        if (found) {
+                            // Находим usage для этой переменной
+                            let scope = currentScope;
+                            let usage;
+                            while (scope) {
+                                if (scope.declarations.has(node.text)) {
+                                    const declScopeId = getScopeId(scope);
+                                    const key = getUsageKey(declScopeId, node.text);
+                                    usage = variableUsages.get(key);
+                                    break;
+                                }
+                                scope = scope.parent;
+                            }
+                            // Заменяем если:
+                            // 1. Переменная используется в другом scope
+                            // 2. Это функция (всегда используем дескриптор)
+                            if (usage && (isUsedInDifferentScope(node.text) || usage.isFunction)) {
+                                // console.log(envPath);
+                                const newEnvPath = (0, utils_1.setParentNodes)(parseEnvPath(envPath), node.parent);
+                                (0, utils_1.markUntouchable)(newEnvPath.expression);
+                                // console.log(printAstNode((newEnvPath as ts.PropertyAccessExpression).expression));
+                                // console.log(newEnvPath.parent);
+                                return newEnvPath;
+                            }
+                        }
+                    }
+                    return typescript_1.default.visitEachChild(node, visitor, context);
+                };
+                const transformedStatements = [];
+                for (const stmt of body.statements) {
+                    // Обрабатываем объявления переменных
+                    if (typescript_1.default.isVariableStatement(stmt)) {
+                        const declarations = [];
+                        for (const decl of stmt.declarationList.declarations) {
+                            if (typescript_1.default.isIdentifier(decl.name)) {
+                                const varName = decl.name.text;
+                                if (isUsedInDifferentScope(varName)) {
+                                    // Переменная используется в другом scope - создаем присваивание в env
+                                    const initializer = decl.initializer
+                                        ? typescript_1.default.visitNode(decl.initializer, visitor)
+                                        : factory.createIdentifier('undefined');
+                                    transformedStatements.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(factory.createIdentifier('__env')), varName), initializer)));
+                                }
+                                else {
+                                    // Переменная не используется в других scope - оставляем обычное объявление
+                                    declarations.push(factory.createVariableDeclaration(decl.name, decl.exclamationToken, decl.type, decl.initializer ? typescript_1.default.visitNode(decl.initializer, visitor) : undefined));
+                                }
+                            }
+                        }
+                        // Если остались обычные декларации, добавляем их
+                        if (declarations.length > 0) {
+                            transformedStatements.push(factory.createVariableStatement(stmt.modifiers, factory.createVariableDeclarationList(declarations, stmt.declarationList.flags)));
+                        }
+                    }
+                    // Обрабатываем вложенные функции
+                    else if (typescript_1.default.isFunctionDeclaration(stmt) && stmt.name) {
+                        const nestedFuncName = stmt.name.text;
+                        // Трансформируем тело вложенной функции
+                        const { body: transformedBody, envAssignments: nestedEnvAssignments } = transformFunctionBody(stmt.body, nestedFuncName);
+                        // Создаем функцию
+                        const funcDecl = factory.createFunctionDeclaration(undefined, stmt.asteriskToken, nestedFuncName, stmt.typeParameters, stmt.parameters, stmt.type, transformedBody);
+                        transformedStatements.push(funcDecl);
+                        // Добавляем env assignments для переменных внутри вложенной функции
+                        transformedStatements.push(...nestedEnvAssignments);
+                        // Создаем дескриптор для вложенной функции
+                        const descriptorStatements = createFunctionDescriptor(nestedFuncName, '__env');
+                        transformedStatements.push(...descriptorStatements);
+                    }
+                    else {
+                        transformedStatements.push(typescript_1.default.visitEachChild(stmt, visitor, context));
+                    }
+                }
+                currentScope = savedScope;
+                return {
+                    body: factory.createBlock(transformedStatements, true),
+                    envAssignments
+                };
+            }
+            function visitTopLevel(node) {
+                // Импорты уже обработаны в НУЛЕВОМ ПРОХОДЕ, пропускаем их здесь
+                if (typescript_1.default.isImportDeclaration(node)) {
+                    return node;
+                }
+                // Обрабатываем export { ... }
+                if (typescript_1.default.isExportDeclaration(node)) {
+                    if (!node.exportClause || !typescript_1.default.isNamedExports(node.exportClause)) {
+                        // export * from '...' - пока не обрабатываем
+                        return node;
+                    }
+                    const result = [];
+                    for (const element of node.exportClause.elements) {
+                        const localName = element.propertyName ? element.propertyName.text : element.name.text;
+                        const exportedName = element.name.text;
+                        // Находим, где объявлена переменная
+                        const { envPath, found } = findDeclaration(localName);
+                        let sourceExpr;
+                        if (found) {
+                            // Проверяем, нужно ли использовать env path
+                            let scope = currentScope;
+                            let usage;
+                            while (scope) {
+                                if (scope.declarations.has(localName)) {
+                                    const declScopeId = getScopeId(scope);
+                                    const key = getUsageKey(declScopeId, localName);
+                                    usage = variableUsages.get(key);
+                                    break;
+                                }
+                                scope = scope.parent;
+                            }
+                            if (usage && (usage.isFunction || isUsedInDifferentScope(localName))) {
+                                const topLevelPath = envPath.replace('__env', '__module_env');
+                                sourceExpr = parseEnvPath(topLevelPath);
+                            }
+                            else {
+                                sourceExpr = factory.createIdentifier(localName);
+                            }
+                        }
+                        else {
+                            sourceExpr = factory.createIdentifier(localName);
+                        }
+                        // __module.exports.exportedName = sourceExpr
+                        const moduleExportPropertyAccessExpression = factory.createPropertyAccessExpression(factory.createIdentifier('__module'), 'exports');
+                        result.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(moduleExportPropertyAccessExpression), exportedName), sourceExpr)));
+                    }
+                    // Добавляем оригинальное export {} в конец для TypeScript declarations
+                    result.push(node);
+                    return result;
+                }
+                // Обрабатываем export default
+                if (typescript_1.default.isExportAssignment(node)) {
+                    // export default expression
+                    const topLevelVisitor = (n) => {
+                        if (typescript_1.default.isIdentifier(n) && n.parent && currentScope) {
+                            if (typescript_1.default.isVariableDeclaration(n.parent) ||
+                                typescript_1.default.isFunctionDeclaration(n.parent) ||
+                                typescript_1.default.isParameter(n.parent) ||
+                                (typescript_1.default.isPropertyAccessExpression(n.parent) && n.parent.name === n) ||
+                                (typescript_1.default.isPropertyAssignment(n.parent) && n.parent.name === n && n !== n.parent.initializer) ||
+                                (typescript_1.default.isBindingElement(n.parent) && n.parent.name === n)) {
+                                return n;
+                            }
+                            const { envPath, found } = findDeclaration(n.text);
+                            if (found) {
+                                let scope = currentScope;
+                                let usage;
+                                while (scope) {
+                                    if (scope.declarations.has(n.text)) {
+                                        const declScopeId = getScopeId(scope);
+                                        const key = getUsageKey(declScopeId, n.text);
+                                        usage = variableUsages.get(key);
+                                        break;
+                                    }
+                                    scope = scope.parent;
+                                }
+                                if (usage && (usage.isFunction || isUsedInDifferentScope(n.text))) {
+                                    const topLevelPath = envPath.replace('__env', '__module_env');
+                                    const newEnvPath = (0, utils_1.setParentNodes)(parseEnvPath(topLevelPath), n.parent);
+                                    (0, utils_1.markUntouchable)(newEnvPath.expression);
+                                    return newEnvPath;
+                                }
+                            }
+                        }
+                        return typescript_1.default.visitEachChild(n, topLevelVisitor, context);
+                    };
+                    const transformedExpression = typescript_1.default.visitNode(node.expression, topLevelVisitor);
+                    // __module.exports.__default = expression
+                    const moduleExportPropertyAccessExpression = factory.createPropertyAccessExpression(factory.createIdentifier('__module'), 'exports');
+                    const exportAssignment = factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(moduleExportPropertyAccessExpression), '__default'), transformedExpression));
+                    // Возвращаем и присваивание и оригинальный export default для TypeScript
+                    return [exportAssignment, node];
+                }
+                // Visitor для замены идентификаторов на top-level
+                const topLevelVisitor = (node) => {
+                    // Обрабатываем идентификаторы (доступ к переменным)
+                    if (typescript_1.default.isIdentifier(node) && node.parent && currentScope) {
+                        // Не трогаем: объявления переменных, имена функций при декларации, property access справа, параметры
+                        // Для PropertyAssignment проверяем, что это имя свойства (name), а не значение (initializer)
+                        if ((typescript_1.default.isVariableDeclaration(node.parent) && node.parent.name === node) ||
+                            typescript_1.default.isFunctionDeclaration(node.parent) ||
+                            typescript_1.default.isParameter(node.parent) ||
+                            (typescript_1.default.isPropertyAccessExpression(node.parent) && node.parent.name === node) ||
+                            (typescript_1.default.isPropertyAssignment(node.parent) && node.parent.name === node && node !== node.parent.initializer) ||
+                            (typescript_1.default.isBindingElement(node.parent) && node.parent.name === node)) {
+                            return node;
+                        }
+                        const { envPath, found } = findDeclaration(node.text);
+                        if (found) {
+                            // Находим usage для этой переменной
+                            let scope = currentScope;
+                            let usage;
+                            while (scope) {
+                                if (scope.declarations.has(node.text)) {
+                                    const declScopeId = getScopeId(scope);
+                                    const key = getUsageKey(declScopeId, node.text);
+                                    usage = variableUsages.get(key);
+                                    break;
+                                }
+                                scope = scope.parent;
+                            }
+                            // На top-level заменяем если это функция (используем дескриптор)
+                            // или если переменная используется в другом scope
+                            if (usage && (usage.isFunction || isUsedInDifferentScope(node.text))) {
+                                // Для top-level используем __module_env вместо __env
+                                const topLevelPath = envPath.replace('__env', '__module_env');
+                                const newEnvPath = (0, utils_1.setParentNodes)(parseEnvPath(topLevelPath), node.parent);
+                                (0, utils_1.markUntouchable)(newEnvPath.expression);
+                                // console.log(printAstNode((newEnvPath as ts.PropertyAccessExpression).expression));
+                                // console.log(newEnvPath.parent);
+                                return newEnvPath;
+                                // return setParentNodes(parseEnvPath(topLevelPath), node.parent);
+                            }
+                        }
+                    }
+                    return typescript_1.default.visitEachChild(node, topLevelVisitor, context);
+                };
+                // Обрабатываем top-level функции
+                if (typescript_1.default.isFunctionDeclaration(node) && node.name) {
+                    const funcName = node.name.text;
+                    const isExported = node.modifiers?.some(mod => mod.kind === typescript_1.default.SyntaxKind.ExportKeyword) || false;
+                    // Добавляем в module scope
+                    if (!currentScope) {
+                        currentScope = createScope('__module_env');
+                    }
+                    addDeclaration(funcName);
+                    // Трансформируем тело функции
+                    const { body: transformedBody, envAssignments } = transformFunctionBody(node.body, funcName);
+                    // Создаем функцию сохраняя export модификатор
+                    const funcDecl = factory.createFunctionDeclaration(node.modifiers, // сохраняем модификаторы включая export
+                    node.asteriskToken, funcName, node.typeParameters, node.parameters, node.type, transformedBody);
+                    const result = [funcDecl];
+                    // Добавляем env assignments для переменных внутри функции
+                    result.push(...envAssignments);
+                    // Создаем дескриптор (с флагом isExported)
+                    const descriptorStatements = createFunctionDescriptor(funcName, '__module_env', isExported);
+                    result.push(...descriptorStatements);
+                    return result;
+                }
+                // Обрабатываем top-level переменные
+                if (typescript_1.default.isVariableStatement(node)) {
+                    if (!currentScope) {
+                        currentScope = createScope('__module_env');
+                    }
+                    const isExported = node.modifiers?.some(mod => mod.kind === typescript_1.default.SyntaxKind.ExportKeyword) || false;
+                    const result = [];
+                    const declarations = [];
+                    for (const decl of node.declarationList.declarations) {
+                        if (typescript_1.default.isIdentifier(decl.name)) {
+                            const varName = decl.name.text;
+                            addDeclaration(varName);
+                            if (isUsedInDifferentScope(varName)) {
+                                // Переменная используется в другом scope - не создаем обычное объявление
+                                // вместо этого сразу записываем в env
+                                const initializer = decl.initializer
+                                    ? typescript_1.default.visitNode(decl.initializer, topLevelVisitor)
+                                    : factory.createIdentifier('undefined');
+                                result.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(factory.createIdentifier('__module_env')), varName), initializer)));
+                            }
+                            else {
+                                // Переменная не используется в других scope - оставляем обычное объявление
+                                const visitedDecl = factory.createVariableDeclaration(decl.name, decl.exclamationToken, decl.type, decl.initializer ? typescript_1.default.visitNode(decl.initializer, topLevelVisitor) : undefined);
+                                declarations.push(visitedDecl);
+                            }
+                            // Если экспортируется, добавляем __module.exports.varName = varName или __module_env.varName
+                            if (isExported) {
+                                const moduleExportPropertyAccessExpression = factory.createPropertyAccessExpression(factory.createIdentifier('__module'), 'exports');
+                                // Если переменная захвачена в __module_env, берем ее оттуда
+                                const sourceExpr = isUsedInDifferentScope(varName)
+                                    ? factory.createPropertyAccessExpression(factory.createIdentifier('__module_env'), varName)
+                                    : factory.createIdentifier(varName);
+                                result.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(moduleExportPropertyAccessExpression), varName), sourceExpr)));
+                            }
+                        }
+                    }
+                    // Если остались обычные декларации, добавляем их первыми (сохраняя export модификатор)
+                    if (declarations.length > 0) {
+                        result.unshift(factory.createVariableStatement(node.modifiers, // сохраняем модификаторы включая export
+                        factory.createVariableDeclarationList(declarations, node.declarationList.flags)));
+                    }
+                    return result.length > 0 ? result : node;
+                }
+                // Для всех остальных top-level statements применяем visitor
+                return typescript_1.default.visitEachChild(node, topLevelVisitor, context);
+            }
+            // НУЛЕВОЙ ПРОХОД: Трансформируем импорты в переменные
+            function transformImports(statements) {
+                const result = [];
+                for (const statement of statements) {
+                    if (typescript_1.default.isImportDeclaration(statement)) {
+                        const moduleSpecifier = statement.moduleSpecifier;
+                        if (!typescript_1.default.isStringLiteral(moduleSpecifier)) {
+                            result.push(statement);
+                            continue;
+                        }
+                        const modulePath = moduleSpecifier.text;
+                        // Генерируем имя переменной для модуля
+                        const moduleVarName = `__module_${modulePath.replace(/[^a-zA-Z0-9]/g, '_')}`;
+                        // var moduleVarName = bt.require(modulePath, UrlParent(AbsoluteUrl("dummy")))
+                        const requireCall = (factory.createCallExpression((0, utils_1.markUntouchable)(factory.createPropertyAccessExpression(factory.createIdentifier('bt'), factory.createIdentifier('require'))), undefined, [
+                            factory.createStringLiteral(modulePath),
+                            factory.createCallExpression(factory.createIdentifier('UrlParent'), undefined, [
+                                factory.createCallExpression(factory.createIdentifier('__AbsoluteUrl'), undefined, [factory.createStringLiteral('dummy')])
+                            ])
+                        ]));
+                        result.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(moduleVarName, undefined, undefined, requireCall)], typescript_1.default.NodeFlags.None)));
+                        // Обрабатываем import clause
+                        if (statement.importClause) {
+                            // import X from "Y" -> var X = moduleY.__default
+                            if (statement.importClause.name) {
+                                const importName = statement.importClause.name.text;
+                                // Пропускаем импорты типов
+                                if (!isTypeOnlyImport(statement.importClause.name)) {
+                                    result.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(importName, undefined, undefined, factory.createPropertyAccessExpression(factory.createIdentifier(moduleVarName), '__default'))], typescript_1.default.NodeFlags.None)));
+                                }
+                            }
+                            // import { a, b as c } from "Y"
+                            if (statement.importClause.namedBindings && typescript_1.default.isNamedImports(statement.importClause.namedBindings)) {
+                                for (const element of statement.importClause.namedBindings.elements) {
+                                    const importedName = element.propertyName ? element.propertyName.text : element.name.text;
+                                    const localName = element.name.text;
+                                    // Пропускаем импорты типов
+                                    if (!isTypeOnlyImport(element.name)) {
+                                        result.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(localName, undefined, undefined, factory.createPropertyAccessExpression(factory.createIdentifier(moduleVarName), importedName))], typescript_1.default.NodeFlags.None)));
+                                    }
+                                }
+                            }
+                            // import * as ns from "Y"
+                            if (statement.importClause.namedBindings && typescript_1.default.isNamespaceImport(statement.importClause.namedBindings)) {
+                                const namespaceName = statement.importClause.namedBindings.name.text;
+                                result.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(namespaceName, undefined, undefined, factory.createIdentifier(moduleVarName))], typescript_1.default.NodeFlags.None)));
+                            }
+                        }
+                    }
+                    else {
+                        result.push(statement);
+                    }
+                }
+                return result.map(stmt => (0, utils_1.setParentNodes)(stmt));
+            }
+            // Трансформируем импорты перед анализом
+            const statementsWithTransformedImports = transformImports(sourceFile.statements);
+            // ПЕРВЫЙ ПРОХОД: Собираем все top-level декларации и анализируем использование
+            currentScope = createScope('__module_env');
+            collectDeclarations(statementsWithTransformedImports);
+            for (const statement of statementsWithTransformedImports) {
+                analyzeUsages(statement);
+            }
+            // ВТОРОЙ ПРОХОД: Трансформируем
+            // Сбрасываем счетчик scope ID и создаем новый module scope
+            scopeIdCounter = 0;
+            currentScope = createScope('__module_env');
+            collectDeclarations(statementsWithTransformedImports);
+            // Трансформируем все statements
+            const transformedStatements = [];
+            for (const statement of statementsWithTransformedImports) {
+                const result = visitTopLevel(statement);
+                if (Array.isArray(result)) {
+                    transformedStatements.push(...result);
+                }
+                else if (result) {
+                    transformedStatements.push(result);
+                }
+            }
+            const newStatements = [moduleEnvDecl, ...transformedStatements];
+            newStatements.forEach(stmt => (0, utils_1.setParentNodes)(stmt, sourceFile));
+            // Возвращаем файл с __module_env в начале и трансформированными statements
+            return (0, utils_1.preserveSymbolsFrom)(factory.updateSourceFile(sourceFile, [moduleEnvDecl, ...transformedStatements]), sourceFile);
+        };
+    };
+}