@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/removeImportExport.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeImportExportTransformer = removeImportExportTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для удаления import/export деклараций.
+ *
+ * BorisScript не поддерживает ES модули, поэтому все import/export
+ * должны быть удалены после обработки remodule трансформером.
+ *
+ * Обрабатывает:
+ * - ImportDeclaration: полностью удаляется
+ * - ExportDeclaration (named): export убирается, declaration остаётся
+ * - ExportDefaultDeclaration: полностью удаляется
+ * - ExportAllDeclaration (export * from): полностью удаляется
+ *
+ * @example
+ * // Вход:
+ * import { foo } from './foo';
+ * export const bar = 1;
+ * export default function main() {}
+ *
+ * // Выход:
+ * const bar = 1;
+ *
+ * @returns TypeScript transformer factory
+ */
+function removeImportExportTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            /**
+             * Visitor для обработки statements на верхнем уровне
+             */
+            const visitor = (node) => {
+                // Удаляем ImportDeclaration
+                if (typescript_1.default.isImportDeclaration(node)) {
+                    return undefined;
+                }
+                // Обрабатываем ExportDeclaration (named exports)
+                if (typescript_1.default.isExportDeclaration(node)) {
+                    // export { foo } from './bar' или export { foo }
+                    // Полностью удаляем
+                    return undefined;
+                }
+                // Обрабатываем ExportAssignment (export default ...)
+                if (typescript_1.default.isExportAssignment(node)) {
+                    // export default expression
+                    return undefined;
+                }
+                // Обрабатываем FunctionDeclaration с export модификатором
+                if (typescript_1.default.isFunctionDeclaration(node)) {
+                    const modifiers = typescript_1.default.getModifiers(node);
+                    const hasExport = modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+                    const hasDefault = modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.DefaultKeyword);
+                    if (hasDefault) {
+                        // export default function ... -> удаляем полностью
+                        return undefined;
+                    }
+                    if (hasExport) {
+                        // export function foo() {} -> function foo() {}
+                        const newModifiers = modifiers?.filter(m => m.kind !== typescript_1.default.SyntaxKind.ExportKeyword);
+                        return typescript_1.default.factory.updateFunctionDeclaration(node, newModifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
+                    }
+                }
+                // Обрабатываем ClassDeclaration с export модификатором
+                if (typescript_1.default.isClassDeclaration(node)) {
+                    const modifiers = typescript_1.default.getModifiers(node);
+                    const hasExport = modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+                    const hasDefault = modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.DefaultKeyword);
+                    if (hasDefault) {
+                        return undefined;
+                    }
+                    if (hasExport) {
+                        const newModifiers = modifiers?.filter(m => m.kind !== typescript_1.default.SyntaxKind.ExportKeyword);
+                        return typescript_1.default.factory.updateClassDeclaration(node, newModifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+                    }
+                }
+                // Обрабатываем VariableStatement с export модификатором
+                if (typescript_1.default.isVariableStatement(node)) {
+                    const modifiers = typescript_1.default.getModifiers(node);
+                    const hasExport = modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+                    if (hasExport) {
+                        // export const foo = 1 -> const foo = 1
+                        const newModifiers = modifiers?.filter(m => m.kind !== typescript_1.default.SyntaxKind.ExportKeyword);
+                        return typescript_1.default.factory.updateVariableStatement(node, newModifiers, node.declarationList);
+                    }
+                }
+                // Обрабатываем InterfaceDeclaration, TypeAliasDeclaration с export
+                // (хотя они должны быть стёрты TypeScript, но на всякий случай)
+                if (typescript_1.default.isInterfaceDeclaration(node) || typescript_1.default.isTypeAliasDeclaration(node)) {
+                    const modifiers = typescript_1.default.getModifiers(node);
+                    const hasExport = modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+                    if (hasExport) {
+                        // Типы не попадают в JS, но если вдруг...
+                        return undefined;
+                    }
+                }
+                // Обрабатываем EnumDeclaration с export модификатором
+                if (typescript_1.default.isEnumDeclaration(node)) {
+                    const modifiers = typescript_1.default.getModifiers(node);
+                    const hasExport = modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+                    if (hasExport) {
+                        const newModifiers = modifiers?.filter(m => m.kind !== typescript_1.default.SyntaxKind.ExportKeyword);
+                        return typescript_1.default.factory.updateEnumDeclaration(node, newModifiers, node.name, node.members);
+                    }
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            const result = typescript_1.default.visitNode(sourceFile, (node) => {
+                if (typescript_1.default.isSourceFile(node)) {
+                    const newStatements = [];
+                    for (const statement of node.statements) {
+                        const result = visitor(statement);
+                        if (result === undefined) {
+                            // Удаляем statement
+                            continue;
+                        }
+                        else if (Array.isArray(result)) {
+                            newStatements.push(...result);
+                        }
+                        else {
+                            newStatements.push(result);
+                        }
+                    }
+                    return typescript_1.default.factory.updateSourceFile(node, newStatements);
+                }
+                return node;
+            });
+            return result;
+        };
+    };
+}

package/build/transformers/replaceDollar.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceDollarTransformer = replaceDollarTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для замены знака доллара ($) в идентификаторах.
+ * В BorisScript символ $ не разрешён в идентификаторах,
+ * поэтому заменяем его на _24_ (ASCII код $).
+ *
+ * @example
+ * // Вход:
+ * const $value = 10;
+ * function $helper() {}
+ * obj.$prop;
+ *
+ * // Выход:
+ * const _24_value = 10;
+ * function _24_helper() {}
+ * obj._24_prop;
+ *
+ * @returns TypeScript transformer factory
+ */
+function replaceDollarTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            const visitor = (node) => {
+                // Обрабатываем идентификаторы
+                if (typescript_1.default.isIdentifier(node)) {
+                    const name = node.text;
+                    if (name.includes('$')) {
+                        const newName = name.replace(/\$/g, '_24_');
+                        return typescript_1.default.factory.createIdentifier(newName);
+                    }
+                }
+                // Обрабатываем строковые литералы в property access (obj["$prop"])
+                // Это может понадобиться если $ используется в строках для доступа к свойствам
+                // Но обычно это не нужно, т.к. строки не являются идентификаторами
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        };
+    };
+}

package/build/transformers/shorthandProperties.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shorthandPropertiesTransformer = shorthandPropertiesTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для преобразования сокращённых свойств объектов в полную форму.
+ *
+ * @example
+ * // Вход:
+ * const obj = { x, y, foo };
+ *
+ * // Выход:
+ * const obj = { x: x, y: y, foo: foo };
+ *
+ * @returns TypeScript transformer factory
+ */
+function shorthandPropertiesTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            const visitor = (node) => {
+                // Обрабатываем свойства объекта
+                if (typescript_1.default.isShorthandPropertyAssignment(node)) {
+                    // Преобразуем { x } в { x: x }
+                    return typescript_1.default.factory.createPropertyAssignment(node.name, typescript_1.default.factory.createIdentifier(node.name.text));
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        };
+    };
+}

package/build/transformers/spreadArray.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spreadArrayTransformer = spreadArrayTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для преобразования spread-элементов в массивах.
+ * Заменяет [...arr] на вызов ArrayUnion().
+ *
+ * @example
+ * // Вход:
+ * const arr = [1, ...other, 2, ...more];
+ *
+ * // Выход:
+ * const arr = ArrayUnion([1], other, [2], more);
+ *
+ * @returns TypeScript transformer factory
+ */
+function spreadArrayTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            const visitor = (node) => {
+                // Обрабатываем массивы
+                if (typescript_1.default.isArrayLiteralExpression(node)) {
+                    // Проверяем наличие spread-элементов
+                    const hasSpread = node.elements.some(el => typescript_1.default.isSpreadElement(el));
+                    if (!hasSpread) {
+                        return typescript_1.default.visitEachChild(node, visitor, context);
+                    }
+                    const args = [];
+                    let currentLiteralArray = [];
+                    // Обрабатываем элементы массива
+                    for (const element of node.elements) {
+                        if (typescript_1.default.isSpreadElement(element)) {
+                            // Если есть накопленные литералы, добавляем их как массив
+                            if (currentLiteralArray.length > 0) {
+                                args.push(typescript_1.default.factory.createArrayLiteralExpression(currentLiteralArray));
+                                currentLiteralArray = [];
+                            }
+                            // Добавляем аргумент spread-элемента (рекурсивно обрабатываем)
+                            const visitedExpression = typescript_1.default.visitNode(element.expression, visitor);
+                            args.push(visitedExpression);
+                        }
+                        else if (typescript_1.default.isOmittedExpression(element)) {
+                            // Пропущенные элементы [1, , 3] -> сохраняем как undefined
+                            currentLiteralArray.push(typescript_1.default.factory.createIdentifier('undefined'));
+                        }
+                        else {
+                            // Собираем не-spread элементы (рекурсивно обрабатываем)
+                            const visitedElement = typescript_1.default.visitNode(element, visitor);
+                            currentLiteralArray.push(visitedElement);
+                        }
+                    }
+                    // Добавляем оставшиеся литералы как массив
+                    if (currentLiteralArray.length > 0) {
+                        args.push(typescript_1.default.factory.createArrayLiteralExpression(currentLiteralArray));
+                    }
+                    // Заменяем выражение массива вызовом ArrayUnion
+                    return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('ArrayUnion'), undefined, args);
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        };
+    };
+}

package/build/transformers/spreadObject.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spreadObjectTransformer = spreadObjectTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для преобразования spread-элементов в объектах.
+ * Заменяет {...obj} на вызовы ObjectUnion().
+ * Также добавляет определение функции ObjectUnion в начало файла при необходимости.
+ *
+ * @example
+ * // Вход:
+ * const obj = { a: 1, ...other, b: 2 };
+ *
+ * // Выход:
+ * function ObjectUnion(obj1, obj2) { ... }
+ * const obj = ObjectUnion(ObjectUnion({ a: 1 }, other), { b: 2 });
+ *
+ * @returns TypeScript transformer factory
+ */
+function spreadObjectTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            let needsObjectUnion = false;
+            const visitor = (node) => {
+                // Обрабатываем объектные литералы
+                if (typescript_1.default.isObjectLiteralExpression(node)) {
+                    // Проверяем наличие spread-элементов
+                    const hasSpread = node.properties.some(prop => typescript_1.default.isSpreadAssignment(prop));
+                    if (!hasSpread) {
+                        return typescript_1.default.visitEachChild(node, visitor, context);
+                    }
+                    needsObjectUnion = true;
+                    const parts = [];
+                    let currentProperties = [];
+                    // Обрабатываем свойства объекта
+                    for (const property of node.properties) {
+                        if (typescript_1.default.isSpreadAssignment(property)) {
+                            // Если есть накопленные свойства, добавляем их как объект
+                            if (currentProperties.length > 0) {
+                                parts.push(typescript_1.default.factory.createObjectLiteralExpression(currentProperties));
+                                currentProperties = [];
+                            }
+                            // Добавляем аргумент spread-элемента (рекурсивно обрабатываем)
+                            const visitedExpression = typescript_1.default.visitNode(property.expression, visitor);
+                            parts.push(visitedExpression);
+                        }
+                        else {
+                            // Собираем не-spread свойства (рекурсивно обрабатываем)
+                            const visitedProperty = typescript_1.default.visitNode(property, visitor);
+                            currentProperties.push(visitedProperty);
+                        }
+                    }
+                    // Добавляем оставшиеся свойства как объект
+                    if (currentProperties.length > 0) {
+                        parts.push(typescript_1.default.factory.createObjectLiteralExpression(currentProperties));
+                    }
+                    // Если частей нет, возвращаем пустой объект
+                    if (parts.length === 0) {
+                        return typescript_1.default.factory.createObjectLiteralExpression([]);
+                    }
+                    // Если только одна часть, оборачиваем в ObjectUnion с пустым объектом
+                    if (parts.length === 1) {
+                        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('ObjectUnion'), undefined, [typescript_1.default.factory.createObjectLiteralExpression([]), parts[0]]);
+                    }
+                    // Строим вложенные вызовы ObjectUnion попарно (left-associative)
+                    let expression = parts[0];
+                    for (let i = 1; i < parts.length; i++) {
+                        expression = typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('ObjectUnion'), undefined, [expression, parts[i]]);
+                    }
+                    return expression;
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            // Сначала обрабатываем всё дерево
+            const visitedSourceFile = typescript_1.default.visitNode(sourceFile, visitor);
+            // Если нужна функция ObjectUnion, добавляем её в начало файла
+            if (needsObjectUnion) {
+                const objectUnionFunction = createObjectUnionFunction();
+                return typescript_1.default.factory.updateSourceFile(visitedSourceFile, [objectUnionFunction, ...visitedSourceFile.statements]);
+            }
+            return visitedSourceFile;
+        };
+    };
+}
+/**
+ * Создаёт AST для функции ObjectUnion:
+ *
+ * function ObjectUnion(obj1, obj2) {
+ *   var newObject = {};
+ *   var key;
+ *   for (key in obj1) {
+ *     newObject.SetProperty(key, obj1.GetProperty(key));
+ *   }
+ *   for (key in obj2) {
+ *     newObject.SetProperty(key, obj2.GetProperty(key));
+ *   }
+ *   return newObject;
+ * }
+ */
+function createObjectUnionFunction() {
+    const obj1 = typescript_1.default.factory.createIdentifier('obj1');
+    const obj2 = typescript_1.default.factory.createIdentifier('obj2');
+    const newObject = typescript_1.default.factory.createIdentifier('newObject');
+    const key = typescript_1.default.factory.createIdentifier('key');
+    // var newObject = {};
+    const newObjectDecl = typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([typescript_1.default.factory.createVariableDeclaration(newObject, undefined, undefined, typescript_1.default.factory.createObjectLiteralExpression([]))], typescript_1.default.NodeFlags.None // var
+    ));
+    // var key;
+    const keyDecl = typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([typescript_1.default.factory.createVariableDeclaration(key)], typescript_1.default.NodeFlags.None // var
+    ));
+    // Создаём for-in цикл для объекта
+    const createForInLoop = (sourceObj) => {
+        // newObject.SetProperty(key, sourceObj.GetProperty(key))
+        const setPropertyCall = typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(newObject, 'SetProperty'), undefined, [
+            key,
+            typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(sourceObj, 'GetProperty'), undefined, [key])
+        ]);
+        return typescript_1.default.factory.createForInStatement(key, sourceObj, typescript_1.default.factory.createBlock([typescript_1.default.factory.createExpressionStatement(setPropertyCall)], true));
+    };
+    // for (key in obj1) { ... }
+    const forInObj1 = createForInLoop(obj1);
+    // for (key in obj2) { ... }
+    const forInObj2 = createForInLoop(obj2);
+    // return newObject;
+    const returnStmt = typescript_1.default.factory.createReturnStatement(newObject);
+    // function ObjectUnion(obj1, obj2) { ... }
+    return typescript_1.default.factory.createFunctionDeclaration(undefined, undefined, 'ObjectUnion', undefined, [
+        typescript_1.default.factory.createParameterDeclaration(undefined, undefined, obj1),
+        typescript_1.default.factory.createParameterDeclaration(undefined, undefined, obj2)
+    ], undefined, typescript_1.default.factory.createBlock([newObjectDecl, keyDecl, forInObj1, forInObj2, returnStmt], true));
+}

package/build/transformers/string.js

@@ -0,0 +1,138 @@
+"use strict";
+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.default = stringTransformer;
+const ts = __importStar(require("typescript"));
+function stringTransformer(program) {
+    return (context) => (file) => {
+        const typeChecker = program.getTypeChecker();
+        function visit(node) {
+            // Проверяем обращения к свойству .length
+            if (ts.isPropertyAccessExpression(node) && node.name.text === 'length') {
+                const expression = node.expression;
+                const type = typeChecker.getTypeAtLocation(expression);
+                // Проверяем, является ли тип строкой или строковым литералом
+                const isStringType = typeChecker.typeToString(type) === 'string' ||
+                    (type.isStringLiteral && type.isStringLiteral()) ||
+                    (type.flags & ts.TypeFlags.StringLike) !== 0;
+                if (isStringType) {
+                    // Заменяем str.length на StrCharCount(str)
+                    return ts.factory.createCallExpression(ts.factory.createIdentifier('StrCharCount'), undefined, [expression]);
+                }
+            }
+            // Проверяем вызовы методов toUpperCase, toLowerCase, startsWith и endsWith
+            if (ts.isCallExpression(node)) {
+                const expression = node.expression;
+                if (ts.isPropertyAccessExpression(expression)) {
+                    const methodName = expression.name.text;
+                    const target = expression.expression;
+                    const type = typeChecker.getTypeAtLocation(target);
+                    // Проверяем, является ли тип строкой или строковым литералом
+                    const isStringType = typeChecker.typeToString(type) === 'string' ||
+                        (type.isStringLiteral && type.isStringLiteral()) ||
+                        (type.flags & ts.TypeFlags.StringLike) !== 0;
+                    if (isStringType) {
+                        // Обработка toUpperCase и toLowerCase
+                        if (methodName === 'toUpperCase' || methodName === 'toLowerCase') {
+                            const functionName = methodName === 'toUpperCase' ? 'StrUpperCase' : 'StrLowerCase';
+                            return ts.factory.createCallExpression(ts.factory.createIdentifier(functionName), undefined, [target]);
+                        }
+                        // Обработка trim
+                        if (methodName === 'trim') {
+                            return ts.factory.createCallExpression(ts.factory.createIdentifier('Trim'), undefined, [target]);
+                        }
+                        // Обработка startsWith
+                        if (methodName === 'startsWith' && node.arguments.length > 0) {
+                            const searchString = node.arguments[0];
+                            const position = node.arguments[1];
+                            if (position) {
+                                // Если передан position, заменяем на StrBegins(StrCharRangePos(str, position, StrCharCount(str)), searchString)
+                                const charRangePosCall = ts.factory.createCallExpression(ts.factory.createIdentifier('StrCharRangePos'), undefined, [
+                                    target,
+                                    position,
+                                    ts.factory.createCallExpression(ts.factory.createIdentifier('StrCharCount'), undefined, [target])
+                                ]);
+                                return ts.factory.createCallExpression(ts.factory.createIdentifier('StrBegins'), undefined, [charRangePosCall, searchString]);
+                            }
+                            else {
+                                // Если position не передан, заменяем на StrBegins(str, searchString)
+                                return ts.factory.createCallExpression(ts.factory.createIdentifier('StrBegins'), undefined, [target, searchString]);
+                            }
+                        }
+                        // Обработка includes
+                        if (methodName === 'includes' && node.arguments.length > 0) {
+                            const searchString = node.arguments[0];
+                            const position = node.arguments[1];
+                            if (position) {
+                                // Если передан position, заменяем на StrContains(StrCharRangePos(str, position, StrCharCount(str)), searchString)
+                                const charRangePosCall = ts.factory.createCallExpression(ts.factory.createIdentifier('StrCharRangePos'), undefined, [
+                                    target,
+                                    position,
+                                    ts.factory.createCallExpression(ts.factory.createIdentifier('StrCharCount'), undefined, [target])
+                                ]);
+                                return ts.factory.createCallExpression(ts.factory.createIdentifier('StrContains'), undefined, [charRangePosCall, searchString]);
+                            }
+                            else {
+                                // Если position не передан, заменяем на StrContains(str, searchString)
+                                return ts.factory.createCallExpression(ts.factory.createIdentifier('StrContains'), undefined, [target, searchString]);
+                            }
+                        }
+                        // Обработка endsWith
+                        if (methodName === 'endsWith' && node.arguments.length > 0) {
+                            const searchString = node.arguments[0];
+                            const length = node.arguments[1];
+                            if (length) {
+                                // Если передан length, заменяем на StrEnds(StrCharRangePos(str, 0, length), searchString)
+                                const charRangePosCall = ts.factory.createCallExpression(ts.factory.createIdentifier('StrCharRangePos'), undefined, [
+                                    target,
+                                    ts.factory.createNumericLiteral('0'),
+                                    length
+                                ]);
+                                return ts.factory.createCallExpression(ts.factory.createIdentifier('StrEnds'), undefined, [charRangePosCall, searchString]);
+                            }
+                            else {
+                                // Если length не передан, заменяем на StrEnds(str, searchString)
+                                return ts.factory.createCallExpression(ts.factory.createIdentifier('StrEnds'), undefined, [target, searchString]);
+                            }
+                        }
+                    }
+                }
+            }
+            // Рекурсивно обходим дочерние узлы
+            return ts.visitEachChild(node, visit, context);
+        }
+        return ts.visitNode(file, visit);
+    };
+}