@boristype/bt-cli 0.1.0-alpha.0

package/build/core/tsconfig.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTSConfig = getTSConfig;
+exports.generateDefaultTSConfig = generateDefaultTSConfig;
+const typescript_1 = __importDefault(require("typescript"));
+const logger_1 = require("./logger");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+function getTSConfig(cwd, project = 'tsconfig.json', options) {
+    const tsconfigPath = typescript_1.default.findConfigFile(cwd, typescript_1.default.sys.fileExists, project);
+    if (!tsconfigPath) {
+        logger_1.logger.error(`There is no any configuration files at "${cwd}". Execute npx tsc -init to create a new one.`);
+        process.exit(1);
+    }
+    const { config, error } = typescript_1.default.readConfigFile(tsconfigPath, typescript_1.default.sys.readFile);
+    if (error) {
+        logger_1.logger.error(error.messageText.toString());
+        process.exit(1);
+    }
+    const configFileContent = typescript_1.default.parseJsonConfigFileContent(config, typescript_1.default.sys, './');
+    if (configFileContent.errors.length > 0) {
+        configFileContent.errors.forEach(x => {
+            logger_1.logger.error(x.messageText.toString());
+        });
+        process.exit(1);
+    }
+    return configFileContent;
+}
+function generateDefaultTSConfig(cwd = process.cwd()) {
+    const tsconfigContent = `{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "Bundler",
+    "rootDir": "./src/",
+    "outDir": "./build/",
+    "strict": true,
+    "noImplicitAny": true,
+    "allowJs": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noLib": true,
+    "typeRoots": [
+      "node_modules/@boristype/types/lib",
+      "node_modules/@boristype/types/lib/xml"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}
+`;
+    const tsconfigPath = (0, node_path_1.join)(cwd, 'tsconfig.json');
+    if ((0, node_fs_1.existsSync)(tsconfigPath)) {
+        logger_1.logger.warning('⚠️  tsconfig.json already exists. Skipping generation.');
+        return false;
+    }
+    try {
+        (0, node_fs_1.writeFileSync)(tsconfigPath, tsconfigContent, 'utf8');
+        logger_1.logger.success('Created a new tsconfig.json');
+        return true;
+    }
+    catch (error) {
+        // A 'tsconfig.json' file is already defined at:
+        // logger.error('❌ Failed to create tsconfig.json:', error);
+        logger_1.logger.error('❌ Failed to create tsconfig.json');
+        throw error;
+    }
+}

package/build/core/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Общие утилиты btc
+ *
+ * @module core/utils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xmlParser = exports.xmlBuilderKeepEmpty = exports.xmlBuilder = exports.parsePropertiesFile = exports.parseProperties = exports.logger = void 0;
+var logger_js_1 = require("./logger.js");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_js_1.logger; } });
+var properties_js_1 = require("./properties.js");
+Object.defineProperty(exports, "parseProperties", { enumerable: true, get: function () { return properties_js_1.parseProperties; } });
+Object.defineProperty(exports, "parsePropertiesFile", { enumerable: true, get: function () { return properties_js_1.parsePropertiesFile; } });
+var xml_js_1 = require("./xml.js");
+Object.defineProperty(exports, "xmlBuilder", { enumerable: true, get: function () { return xml_js_1.xmlBuilder; } });
+Object.defineProperty(exports, "xmlBuilderKeepEmpty", { enumerable: true, get: function () { return xml_js_1.xmlBuilderKeepEmpty; } });
+Object.defineProperty(exports, "xmlParser", { enumerable: true, get: function () { return xml_js_1.xmlParser; } });

package/build/core/utils/logger.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Logger — цветной вывод в консоль
+ *
+ * Использует `util.styleText` из Node.js 21.7+ для раскраски.
+ * На более старых версиях выводит plain text.
+ *
+ * @module core/utils/logger
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const node_util_1 = __importDefault(require("node:util"));
+class Logger {
+    #styleText = (_color, message) => message;
+    constructor() {
+        this.#reimplementStyleText();
+    }
+    /** Вывод ошибки (красный) */
+    error(message) {
+        console.error(this.#styleText('red', message));
+    }
+    /** Вывод успешного результата (зелёный) */
+    success(message) {
+        console.log(this.#styleText('greenBright', message));
+    }
+    /** Вывод предупреждения (жёлтый) */
+    warning(message) {
+        console.warn(this.#styleText('yellow', message));
+    }
+    /** Вывод информации (голубой) */
+    info(message) {
+        console.log(this.#styleText('cyan', message));
+    }
+    #reimplementStyleText() {
+        const nodeVersionArray = process.versions.node.split('.');
+        if (Number(nodeVersionArray[0]) > 21 ||
+            (Number(nodeVersionArray[0]) === 21 && Number(nodeVersionArray[1]) > 7)) {
+            this.#styleText = node_util_1.default.styleText;
+        }
+    }
+}
+/** Глобальный синглтон логгера */
+exports.logger = new Logger();

package/build/core/utils/properties.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Generic .properties file parser
+ *
+ * Формат: key=value, одна пара на строку.
+ * Строки начинающиеся с `#` — комментарии.
+ * Пустые строки игнорируются.
+ *
+ * @module core/utils/properties
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProperties = parseProperties;
+exports.parsePropertiesFile = parsePropertiesFile;
+const fs = __importStar(require("node:fs"));
+/**
+ * Парсит содержимое в формате `.properties` (key=value).
+ *
+ * @param content - текстовое содержимое файла
+ * @returns объект ключ-значение
+ */
+function parseProperties(content) {
+    const lines = content.split(/\r?\n/);
+    const result = {};
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine === '' || trimmedLine.startsWith('#')) {
+            continue;
+        }
+        const [key, value] = trimmedLine.split('=', 2);
+        if (key && value !== undefined) {
+            result[key.trim()] = value.trim();
+        }
+    }
+    return result;
+}
+/**
+ * Читает и парсит `.properties` файл.
+ *
+ * @param filePath - абсолютный путь к файлу
+ * @returns объект ключ-значение, или пустой объект если файл не существует
+ */
+function parsePropertiesFile(filePath) {
+    if (!fs.existsSync(filePath) || !fs.lstatSync(filePath).isFile()) {
+        return {};
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return parseProperties(content);
+}

package/build/core/utils/xml.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Общие XML builder/parser пресеты
+ *
+ * Централизованные экземпляры XMLBuilder/XMLParser для использования
+ * в linking-генераторах, building/output и других модулях.
+ *
+ * @module core/utils/xml
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xmlParser = exports.xmlBuilderKeepEmpty = exports.xmlBuilder = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+/** Общие опции для всех XML builder'ов */
+const BASE_BUILDER_OPTIONS = {
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    format: true,
+    indentBy: '\t',
+    processEntities: true,
+};
+/**
+ * XML builder с подавлением пустых узлов.
+ * Используется для init.xml, SPXML output.
+ */
+exports.xmlBuilder = new fast_xml_parser_1.XMLBuilder({
+    ...BASE_BUILDER_OPTIONS,
+    suppressEmptyNode: true,
+});
+/**
+ * XML builder без подавления пустых узлов.
+ * Используется для api_ext.xml, component SPXML.
+ */
+exports.xmlBuilderKeepEmpty = new fast_xml_parser_1.XMLBuilder({
+    ...BASE_BUILDER_OPTIONS,
+    suppressEmptyNode: false,
+});
+/**
+ * XML parser с поддержкой атрибутов.
+ * Используется для чтения init.xml, api_ext.xml.
+ */
+exports.xmlParser = new fast_xml_parser_1.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+});

package/build/core/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlAppenPath = UrlAppenPath;
+function UrlAppenPath(url, appendPath) {
+    var parsedUrl;
+    var addPath;
+    parsedUrl = BmParseUrl(url);
+    if (!parsedUrl.path.endsWith("/"))
+        parsedUrl.path += '/';
+    addPath = appendPath;
+    if (addPath.charAt(0) == '/')
+        addPath = addPath.slice(1);
+    parsedUrl.path += addPath;
+    return BmParsedUrl__GetStrValue(parsedUrl);
+}
+function BmParseUrl(urlStr) {
+    var obj = {};
+    var tempStr;
+    var pos;
+    tempStr = urlStr;
+    pos = String(tempStr).indexOf(':');
+    if (pos >= 0) {
+        obj.schema = tempStr.slice(0, pos);
+        tempStr = tempStr.slice(pos + 1);
+    }
+    if (tempStr.startsWith('//')) {
+        pos = String(tempStr).indexOf('/', 2);
+        if (pos < 0)
+            pos = tempStr.length;
+        obj.host = tempStr.slice(2, pos);
+        tempStr = tempStr.slice(pos);
+    }
+    if ((pos = String(tempStr).lastIndexOf('#')) > 0) {
+        obj.anchor = tempStr.slice(pos + 1);
+        tempStr = tempStr.slice(0, pos);
+    }
+    if ((pos = String(tempStr).lastIndexOf('?')) > 0) {
+        obj.param = tempStr.slice(pos + 1);
+        tempStr = tempStr.slice(0, pos);
+    }
+    obj.path = tempStr;
+    if (obj.path == "" && obj.host)
+        obj.path = "/";
+    return obj;
+}
+function BmParsedUrl__GetStrValue(url) {
+    var tempStr = "";
+    if (url.schema)
+        tempStr = url.schema + ":";
+    if (url.host || url.schema == "file")
+        tempStr += "//" + url.host;
+    tempStr += url.path;
+    if (url.param)
+        tempStr += "?" + url.param;
+    if (url.fragment)
+        tempStr += "#" + url.fragment;
+    return tempStr;
+}
+;

package/build/index.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const package_json_1 = __importDefault(require("../package.json"));
+const commands_1 = require("./cli/commands");
+commander_1.program
+    .name('btc')
+    .description(package_json_1.default.description)
+    .version(package_json_1.default.version);
+// Команда init
+commander_1.program
+    .command('init')
+    .description('Initialize a BorisType project and create a tsconfig.json file')
+    .action(async () => {
+    await (0, commands_1.initCommand)();
+});
+// Команда build (по умолчанию)
+commander_1.program
+    .command('build [files...]', { isDefault: true })
+    .description('Transpile TypeScript to BorisScript')
+    .option('--outDir <dir>', 'Directory to save processed files')
+    .option('--include-non-ts-files', 'Process files that are not TypeScript', false)
+    .option('--retain-non-ascii-characters', 'Keep non-ASCII characters in source files', false)
+    .option('--remove-comments', 'Remove comments from source files', false)
+    .option('--off-babel', '[DEBUG] Toggle off all babel transformations', false)
+    .option('--compile-mode <mode>', 'Transpilation mode: bare | script | module (default: module)')
+    .option('--no-use-polyfill', '[deprecated] Use --compile-mode bare')
+    .option('--no-use-remodule', '[deprecated] Use --compile-mode bare')
+    .action(async (files, options) => {
+    await (0, commands_1.buildCommand)(files, options);
+});
+// Команда link
+commander_1.program
+    .command('link')
+    .description('Link modules and dependencies into dist structure')
+    .option('--clean', 'Clean dist directory and cache before linking', false)
+    .option('--no-cache', 'Do not use cache for node_modules (but do not delete it)')
+    .option('--linking-system-as <mode>', 'How to link system packages: "standalone" or "component"', 'component')
+    .action(async (options) => {
+    const systemMode = options.linkingSystemAs;
+    // Commander парсит --no-cache как cache: false (по умолчанию cache: true)
+    await (0, commands_1.linkCommand)({ clean: options.clean, noCache: options.cache === false, linkingSystemAs: systemMode });
+});
+// Команда artifact
+commander_1.program
+    .command('artifact')
+    .description('Create distribution archive from dist folder')
+    .option('--clean', 'Clean artifact directory before creating archives', false)
+    .action(async (options) => {
+    await (0, commands_1.artifactCommand)(options);
+});
+// Команда dev
+commander_1.program
+    .command('dev')
+    .description('Start development mode with watch')
+    .option('--no-push', 'Disable auto-push to WSHCM server after linking')
+    .action(async (options) => {
+    await (0, commands_1.devCommand)({ push: options.push });
+});
+// Команда push (загрузка dist на WSHCM сервер)
+commander_1.program
+    .command('push')
+    .description('Upload dist folder to WSHCM server')
+    .option('--host <host>', 'WSHCM server host (default: localhost)')
+    .option('--port <port>', 'WSHCM server port (default: 80)', parseInt)
+    .option('--username <username>', 'Username for authentication (default: user1)')
+    .option('--password <password>', 'Password for authentication (default: user1)')
+    .option('--https', 'Use HTTPS instead of HTTP', false)
+    .action(async (options) => {
+    await (0, commands_1.pushCommand)(options);
+});
+commander_1.program.parse(process.argv);

package/build/plugins/destructuring.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = replaceDestructuringPlugin;
+const core_1 = require("@babel/core");
+function makeDestructuringPolyfillExpression(functionName) {
+    return core_1.types.memberExpression(core_1.types.identifier('bt'), core_1.types.identifier(functionName));
+}
+function replaceDestructuringPlugin() {
+    return {
+        name: 'replace-destructuring',
+        visitor: {
+            VariableDeclaration(path, state) {
+                const declarations = path.node.declarations;
+                const newDeclarations = [];
+                // Process each variable declarator
+                declarations.forEach((declarator) => {
+                    // Handle object destructuring
+                    if (core_1.types.isObjectPattern(declarator.id)) {
+                        const properties = declarator.id.properties;
+                        const init = declarator.init;
+                        const excludedKeys = [];
+                        // Collect excluded keys and handle regular properties
+                        properties.forEach((prop) => {
+                            if (core_1.types.isObjectProperty(prop)) {
+                                const key = prop.key;
+                                const value = prop.value;
+                                if (core_1.types.isIdentifier(key) && core_1.types.isIdentifier(value)) {
+                                    // Create new declaration: const key1 = testObject1.key1
+                                    const newDeclarator = core_1.types.variableDeclarator(core_1.types.identifier(value.name), core_1.types.memberExpression(init, key));
+                                    newDeclarations.push(core_1.types.variableDeclaration(path.node.kind, [newDeclarator]));
+                                    // Collect key for exclusion
+                                    excludedKeys.push(core_1.types.stringLiteral(key.name));
+                                }
+                            }
+                            else if (core_1.types.isRestElement(prop)) {
+                                state.needsObjectRest = true;
+                                // Handle rest element (...restKeys)
+                                const restIdent = prop.argument;
+                                if (core_1.types.isIdentifier(restIdent)) {
+                                    const restCall = core_1.types.callExpression(makeDestructuringPolyfillExpression("object_rest"), [init, core_1.types.arrayExpression(excludedKeys)]);
+                                    const newDeclarator = core_1.types.variableDeclarator(restIdent, restCall);
+                                    newDeclarations.push(core_1.types.variableDeclaration(path.node.kind, [newDeclarator]));
+                                }
+                            }
+                        });
+                    }
+                    // Handle array destructuring
+                    else if (core_1.types.isArrayPattern(declarator.id)) {
+                        const elements = declarator.id.elements;
+                        const init = declarator.init;
+                        // Generate unique auxiliary variable name
+                        const auxVarName = path.scope.generateUidIdentifier('arr');
+                        // Create auxiliary variable: const _arr = ArrayDirect(testArray1)
+                        const auxDeclarator = core_1.types.variableDeclarator(auxVarName, core_1.types.callExpression(core_1.types.identifier('ArrayDirect'), [init]));
+                        newDeclarations.push(core_1.types.variableDeclaration(path.node.kind, [auxDeclarator]));
+                        // Process array elements
+                        elements.forEach((element, index) => {
+                            if (core_1.types.isIdentifier(element)) {
+                                // Create new declaration: const elem1 = _arr[0]
+                                const newDeclarator = core_1.types.variableDeclarator(element, core_1.types.memberExpression(auxVarName, core_1.types.numericLiteral(index), true));
+                                newDeclarations.push(core_1.types.variableDeclaration(path.node.kind, [newDeclarator]));
+                            }
+                            else if (core_1.types.isRestElement(element)) {
+                                state.needsArrayRest = true;
+                                // Handle rest element (...restElems)
+                                const restIdent = element.argument;
+                                if (core_1.types.isIdentifier(restIdent)) {
+                                    const restCall = core_1.types.callExpression(makeDestructuringPolyfillExpression("array_rest"), [auxVarName, core_1.types.numericLiteral(index)]);
+                                    const newDeclarator = core_1.types.variableDeclarator(restIdent, restCall);
+                                    newDeclarations.push(core_1.types.variableDeclaration(path.node.kind, [newDeclarator]));
+                                }
+                            }
+                        });
+                    }
+                });
+                // Replace original declaration with new ones if any were created
+                if (newDeclarations.length > 0) {
+                    path.replaceWithMultiple(newDeclarations);
+                }
+            },
+        },
+    };
+}

package/build/plugins/forOfToForIn.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = replaceForOfToForInPlugin;
+const core_1 = require("@babel/core");
+function replaceForOfToForInPlugin() {
+    return {
+        name: 'replace-for-of-to-for-in',
+        visitor: {
+            ForOfStatement(path) {
+                path.replaceWith(core_1.types.forInStatement(path.node.left, path.node.right, path.node.body));
+            },
+        },
+    };
+}

package/build/plugins/loopHoistVariables.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = collectLoopVariablesPlugin;
+const core_1 = require("@babel/core");
+const isLoop = (node) => {
+    return (core_1.types.isForStatement(node) ||
+        core_1.types.isForInStatement(node) ||
+        core_1.types.isForOfStatement(node) ||
+        core_1.types.isWhileStatement(node) ||
+        core_1.types.isDoWhileStatement(node));
+};
+// Initialize loop state for a top-level loop
+function enterLoop(state) {
+    if (!state.isInLoop) {
+        state.isInLoop = true;
+        state.loopVariables = new Map();
+        state.loopCounter = (state.loopCounter || 0) + 1; // Increment loop counter
+    }
+}
+// Collect variables from ForIn/ForOf loop headers and replace declarations
+function collectLoopHeaderVariables(path, state) {
+    if (core_1.types.isVariableDeclaration(path.node.left)) {
+        const kind = path.node.left.kind;
+        path.node.left.declarations.forEach((decl) => {
+            if (core_1.types.isIdentifier(decl.id)) {
+                const newName = `${decl.id.name}_loop${state.loopCounter}`;
+                state.loopVariables.set(decl.id.name, { kind, newName });
+                // Rename references in the scope
+                path.scope.rename(decl.id.name, newName);
+            }
+            else if (core_1.types.isObjectPattern(decl.id) || core_1.types.isArrayPattern(decl.id)) {
+                const identifiers = core_1.types.getBindingIdentifiers(decl.id);
+                Object.keys(identifiers).forEach((name) => {
+                    const newName = `${name}_loop${state.loopCounter}`;
+                    state.loopVariables.set(name, { kind, newName });
+                    path.scope.rename(name, newName);
+                });
+            }
+        });
+        // Replace VariableDeclaration with just the identifier or pattern
+        path.node.left = path.node.left.declarations[0].id;
+    }
+}
+// Handle loop exit: log variables, insert declarations, reset state
+function exitLoop(path, state) {
+    if (!path.findParent((p) => isLoop(p.node))) {
+        // Log collected variables
+        // console.log(
+        //   'Variables declared in loop:',
+        //   Array.from(state.loopVariables.entries()).map(([name, { kind, newName }]) => [name, kind, newName])
+        // );
+        // Create variable declarations with empty initialization
+        const declarations = [];
+        state.loopVariables.forEach(({ kind, newName }) => {
+            const init = kind === 'const' ? core_1.types.nullLiteral() : core_1.types.identifier('undefined');
+            const declarator = core_1.types.variableDeclarator(core_1.types.identifier(newName), init);
+            declarations.push(core_1.types.variableDeclaration(kind, [declarator]));
+        });
+        // Insert declarations before the top-level loop
+        if (declarations.length > 0) {
+            const parent = path.getStatementParent();
+            if (parent) {
+                parent.insertBefore(declarations);
+            }
+        }
+        // Reset state
+        state.isInLoop = false;
+        state.loopVariables = new Map();
+    }
+}
+function collectLoopVariablesPlugin() {
+    return {
+        name: 'collect-loop-variables',
+        pre() {
+            this.loopVariables = new Map();
+            this.isInLoop = false;
+            this.loopCounter = 0;
+        },
+        visitor: {
+            ForStatement: {
+                enter(path, state) {
+                    enterLoop(state);
+                },
+                exit(path, state) {
+                    exitLoop(path, state);
+                },
+            },
+            ForInStatement: {
+                enter(path, state) {
+                    enterLoop(state);
+                    collectLoopHeaderVariables(path, state);
+                },
+                exit(path, state) {
+                    exitLoop(path, state);
+                },
+            },
+            ForOfStatement: {
+                enter(path, state) {
+                    enterLoop(state);
+                    collectLoopHeaderVariables(path, state);
+                },
+                exit(path, state) {
+                    exitLoop(path, state);
+                },
+            },
+            WhileStatement: {
+                enter(path, state) {
+                    enterLoop(state);
+                },
+                exit(path, state) {
+                    exitLoop(path, state);
+                },
+            },
+            DoWhileStatement: {
+                enter(path, state) {
+                    enterLoop(state);
+                },
+                exit(path, state) {
+                    exitLoop(path, state);
+                },
+            },
+            VariableDeclaration(path, state) {
+                if (state.isInLoop) {
+                    const kind = path.node.kind; // 'const', 'let', or 'var'
+                    const assignments = [];
+                    path.node.declarations.forEach((decl) => {
+                        if (core_1.types.isIdentifier(decl.id)) {
+                            const newName = `${decl.id.name}_loop${state.loopCounter}`;
+                            state.loopVariables.set(decl.id.name, { kind, newName });
+                            // Rename references in the scope
+                            path.scope.rename(decl.id.name, newName);
+                            // Create assignment expression (e.g., x_loopN = 5 or x_loopN = undefined)
+                            const init = decl.init || core_1.types.identifier('undefined');
+                            assignments.push(core_1.types.expressionStatement(core_1.types.assignmentExpression('=', core_1.types.identifier(newName), init)));
+                        }
+                        else if (core_1.types.isObjectPattern(decl.id) || core_1.types.isArrayPattern(decl.id)) {
+                            // Handle destructuring
+                            const identifiers = core_1.types.getBindingIdentifiers(decl.id);
+                            Object.keys(identifiers).forEach((name) => {
+                                const newName = `${name}_loop${state.loopCounter}`;
+                                state.loopVariables.set(name, { kind, newName });
+                                path.scope.rename(name, newName);
+                                // Create individual assignments for each identifier
+                                const init = decl.init || core_1.types.identifier('undefined');
+                                assignments.push(core_1.types.expressionStatement(core_1.types.assignmentExpression('=', core_1.types.identifier(newName), init)));
+                            });
+                        }
+                    });
+                    // Replace VariableDeclaration with assignments
+                    if (assignments.length > 0) {
+                        path.replaceWithMultiple(assignments);
+                    }
+                    else {
+                        path.remove(); // Remove empty declarations
+                    }
+                }
+            },
+        },
+    };
+}