typenative 0.0.18 → 0.0.20

package/bin/transpiler.js

@@ -6,7 +6,16 @@ const importedPackages = new Set();
 let outsideNodes = [];
 const classNames = new Set();
 let promiseResolveName = '';
-const dangerousNames = new Set(['main']);
+// Go keywords that cannot be used as identifiers
+const dangerousNames = new Set([
+    'main',
+    // Go reserved keywords
+    'break', 'case', 'chan', 'const', 'continue',
+    'default', 'defer', 'else', 'fallthrough', 'for',
+    'func', 'go', 'goto', 'if', 'import',
+    'interface', 'map', 'package', 'range', 'return',
+    'select', 'struct', 'switch', 'type', 'var',
+]);
 const renamedFunctions = new Map();
 const variableTypes = new Map();
 const variableGoTypes = new Map();
@@ -17,7 +26,29 @@ const interfacePropertyTypes = new Map();
 const typeAliases = new Map();
 const enumNames = new Set();
 const enumBaseTypes = new Map();
-export function transpileToNative(code) {
+// Maps local TS name → Go qualified name (e.g. 'Println' → 'fmt.Println', 'myFmt' → 'fmt')
+const importAliases = new Map();
+// Tracks static methods per class: Set of "ClassName.methodName" strings
+const classStaticMethods = new Set();
+// Tracks static properties per class: Set of "ClassName.propName" strings
+const classStaticProps = new Set();
+// Callback for resolving import specifiers to source code.
+// specifier: the raw import string (relative path or package name)
+// fromDir: directory of the file containing the import (null = main file's dir)
+// Returns the file content and its directory (for resolving that file's own imports)
+let fileResolver = null;
+// Directory of the file currently being processed (null = main entry file)
+let currentFileDir = null;
+// Tracks already-included files by a stable key to prevent duplicates/cycles
+const includedLocalImports = new Set();
+// Collects Go source files generated from local TS imports (filename → content)
+let localImportFiles = new Map();
+// Default import namespaces from npm/local packages (e.g. `import ts from 'typescript'` → 'ts')
+// Property accesses on these are stripped: ts.createSourceFile → createSourceFile
+const defaultImportNamespaces = new Set();
+export function transpileToNative(code, options) {
+    fileResolver = options?.readFile ?? null;
+    currentFileDir = null;
     const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
     TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
     importedPackages.clear();
@@ -34,17 +65,24 @@ export function transpileToNative(code) {
     typeAliases.clear();
     enumNames.clear();
     enumBaseTypes.clear();
+    importAliases.clear();
+    includedLocalImports.clear();
+    localImportFiles = new Map();
+    defaultImportNamespaces.clear();
+    classStaticMethods.clear();
+    classStaticProps.clear();
     const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
     const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
-    return `package main
+    const main = `package main
 
 ${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
 
 func main() {
     ${transpiledCode.trim()}
 }
- 
+
 ${transpiledCodeOutside.trim()}`;
+    return { main, files: localImportFiles };
 }
 export function visit(node, options = {}) {
     let code = '';
@@ -57,6 +95,9 @@ export function visit(node, options = {}) {
     else if (ts.isIdentifier(node)) {
         if (node.text === 'undefined')
             return 'nil';
+        const goAlias = importAliases.get(node.text);
+        if (goAlias)
+            return goAlias;
         return getSafeName(node.text);
     }
     else if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
@@ -95,6 +136,10 @@ export function visit(node, options = {}) {
     }
     else if (ts.isArrayLiteralExpression(node)) {
         const type = ts.isVariableDeclaration(node.parent) ? getType(node.parent.type, true) : '';
+        const hasSpread = node.elements.some((e) => ts.isSpreadElement(e));
+        if (hasSpread) {
+            return visitSpreadArrayLiteral(node, type);
+        }
         return `[]${type} {${node.elements.map((e) => visit(e)).join(', ')}}`;
     }
     else if (ts.isBlock(node)) {
@@ -115,12 +160,57 @@ export function visit(node, options = {}) {
         if (ts.isIdentifier(node.expression) && enumNames.has(node.expression.text)) {
             return `${getSafeName(node.expression.text)}_${getEnumMemberName(node.name)}`;
         }
+        // Strip default import namespace: `ts.createSourceFile` → `createSourceFile`
+        if (ts.isIdentifier(node.expression) && defaultImportNamespaces.has(node.expression.text)) {
+            return visit(node.name);
+        }
+        // Static member access: `Counter.count` → `Counter_count`
+        if (ts.isIdentifier(node.expression)) {
+            const key = `${node.expression.text}.${node.name.text}`;
+            if (classStaticMethods.has(key) || classStaticProps.has(key)) {
+                return `${node.expression.text}_${node.name.text}`;
+            }
+        }
         const leftSide = visit(node.expression);
         const rightSide = visit(node.name);
         const objectType = resolveExpressionType(node.expression);
         return getAcessString(leftSide, rightSide, objectType);
     }
     else if (ts.isVariableDeclaration(node)) {
+        // Object destructuring: const { x, y } = obj
+        if (ts.isObjectBindingPattern(node.name) && node.initializer) {
+            const initExpr = visit(node.initializer);
+            const parts = node.name.elements.map((el) => {
+                const localName = visit(el.name);
+                const propName = el.propertyName ? visit(el.propertyName) : localName;
+                const defaultVal = el.initializer ? visit(el.initializer) : undefined;
+                if (defaultVal) {
+                    return `${localName} := func() interface{} { if ${initExpr}.${propName} == nil { return ${defaultVal} }; return ${initExpr}.${propName} }()`;
+                }
+                return `${localName} := ${initExpr}.${propName}`;
+            });
+            return parts.join(';\n\t');
+        }
+        // Array destructuring: const [a, b] = arr
+        if (ts.isArrayBindingPattern(node.name) && node.initializer) {
+            const initExpr = visit(node.initializer);
+            const tmpVar = getTempName('arr');
+            const parts = [`${tmpVar} := ${initExpr}`];
+            node.name.elements.forEach((el, idx) => {
+                if (ts.isOmittedExpression(el))
+                    return;
+                const bindEl = el;
+                const localName = visit(bindEl.name);
+                // Variables starting with _ are intentionally unused — use blank identifier
+                if (localName === '_' || localName.startsWith('_')) {
+                    parts.push(`_ = ${tmpVar}[${idx}]`);
+                }
+                else {
+                    parts.push(`${localName} := ${tmpVar}[${idx}]`);
+                }
+            });
+            return parts.join(';\n\t');
+        }
         const type = getType(node.type);
         // Track variable type for type-aware method dispatch
         if (ts.isIdentifier(node.name)) {
@@ -175,6 +265,19 @@ export function visit(node, options = {}) {
             (ts.isPropertyAccessExpression(node.expression) && hasQuestionDot(node.expression))) {
             return visitOptionalCall(node);
         }
+        // IIFE with named function expression: (function name() { ... })()
+        if (ts.isParenthesizedExpression(node.expression) &&
+            ts.isFunctionExpression(node.expression.expression)) {
+            const fn = node.expression.expression;
+            const parameterInfo = getFunctionParametersInfo(fn.parameters);
+            if (fn.body && ts.isBlock(fn.body)) {
+                prescanVariableDeclarations(fn.body);
+            }
+            const inferredRetType = inferFunctionBodyReturnType(fn);
+            const returnType = inferredRetType ? ` ${inferredRetType}` : '';
+            const args = node.arguments.map((a) => visit(a)).join(', ');
+            return `func(${parameterInfo.signature})${returnType} ${visit(fn.body, { prefixBlockContent: parameterInfo.prefixBlockContent })}(${args})`;
+        }
         // Handle setTimeout specially to get raw delay value
         if (ts.isIdentifier(node.expression) && node.expression.text === 'setTimeout') {
             importedPackages.add('time');
@@ -190,7 +293,11 @@ export function visit(node, options = {}) {
         const caller = visit(node.expression);
         const safeCaller = getSafeName(caller);
         const typeArgs = getTypeArguments(node.typeArguments);
-        const args = node.arguments.map((a) => visit(a));
+        // Handle spread arguments: fn(...arr) → fn(arr...)
+        const hasSpreadArg = node.arguments.some((a) => ts.isSpreadElement(a));
+        const args = hasSpreadArg
+            ? node.arguments.map((a) => ts.isSpreadElement(a) ? `${visit(a.expression)}...` : visit(a))
+            : node.arguments.map((a) => visit(a));
         // Resolve object type for type-aware method dispatch
         let objectType;
         if (ts.isPropertyAccessExpression(node.expression)) {
@@ -236,9 +343,25 @@ export function visit(node, options = {}) {
             inline: true
         })}; ${visit(node.incrementor, { inline: true })}${visit(node.statement)}`;
     }
+    else if (ts.isForInStatement(node)) {
+        const varName = ts.isVariableDeclarationList(node.initializer)
+            ? visit(node.initializer.declarations[0].name)
+            : visit(node.initializer);
+        return `for ${varName} := range ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
+    }
     else if (ts.isForOfStatement(node)) {
-        const iterExpr = visit(node.expression, { inline: true });
-        const iterType = inferExpressionType(node.expression);
+        // Unwrap Object.entries(x) → treat x as the iterable
+        let iterNode = node.expression;
+        if (ts.isCallExpression(iterNode) &&
+            ts.isPropertyAccessExpression(iterNode.expression) &&
+            ts.isIdentifier(iterNode.expression.expression) &&
+            iterNode.expression.expression.text === 'Object' &&
+            iterNode.expression.name.text === 'entries' &&
+            iterNode.arguments.length > 0) {
+            iterNode = iterNode.arguments[0];
+        }
+        const iterExpr = visit(iterNode, { inline: true });
+        const iterType = inferExpressionType(iterNode);
         if (iterType && iterType.startsWith('map[')) {
             const valueType = extractMapValueType(iterType);
             const isSet = valueType === 'struct{}';
@@ -436,11 +559,23 @@ export function visit(node, options = {}) {
             const properties = new Map();
             const methods = new Map();
             for (const member of node.members) {
+                const memberModifiers = member.modifiers;
+                const isStatic = memberModifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
                 if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
-                    properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+                    if (isStatic) {
+                        classStaticProps.add(`${className}.${member.name.text}`);
+                    }
+                    else {
+                        properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+                    }
                 }
                 if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name)) {
-                    methods.set(member.name.text, member.type ? getType(member.type) : 'interface{}');
+                    if (isStatic) {
+                        classStaticMethods.add(`${className}.${member.name.text}`);
+                    }
+                    else {
+                        methods.set(member.name.text, member.type ? getType(member.type) : 'interface{}');
+                    }
                 }
             }
             classPropertyTypes.set(className, properties);
@@ -498,9 +633,36 @@ export function visit(node, options = {}) {
                 const methodName = visit(member.name);
                 const methodParameterInfo = getFunctionParametersInfo(member.parameters);
                 const returnType = member.type ? ` ${getType(member.type)}` : '';
-                result += `func (self *${name}${typeParamNames}) ${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, {
-                    prefixBlockContent: methodParameterInfo.prefixBlockContent
-                })}\n\n`;
+                const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+                if (isStatic) {
+                    // Static methods become package-level functions named ClassName_methodName
+                    result += `func ${name}_${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, { prefixBlockContent: methodParameterInfo.prefixBlockContent })}\n\n`;
+                }
+                else {
+                    result += `func (self *${name}${typeParamNames}) ${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, { prefixBlockContent: methodParameterInfo.prefixBlockContent })}\n\n`;
+                }
+            }
+            else if (ts.isGetAccessor(member)) {
+                // Getter: get prop() { ... } → func (self *T) Prop() RetType { ... }
+                const getterName = visit(member.name);
+                const returnType = member.type ? ` ${getType(member.type)}` : ' interface{}';
+                result += `func (self *${name}${typeParamNames}) Get_${getterName}()${returnType} ${visit(member.body)}\n\n`;
+            }
+            else if (ts.isSetAccessor(member)) {
+                // Setter: set prop(val) { ... } → func (self *T) SetProp(val ValType) { ... }
+                const setterName = visit(member.name);
+                const parameterInfo = getFunctionParametersInfo(member.parameters);
+                result += `func (self *${name}${typeParamNames}) Set_${setterName}(${parameterInfo.signature}) ${visit(member.body, { prefixBlockContent: parameterInfo.prefixBlockContent })}\n\n`;
+            }
+        }
+        // Static property declarations → package-level vars named ClassName_propName
+        for (const member of node.members) {
+            if (ts.isPropertyDeclaration(member) &&
+                member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
+                const fieldName = visit(member.name);
+                const fieldType = getOptionalNodeType(member.type, !!member.questionToken);
+                const initializer = member.initializer ? ` = ${visit(member.initializer)}` : '';
+                result += `var ${name}_${fieldName} ${fieldType}${initializer}\n\n`;
             }
         }
         return result.trim();
@@ -543,6 +705,12 @@ export function visit(node, options = {}) {
             if (ts.isPropertyAssignment(p)) {
                 return `${visit(p.name)}: ${visit(p.initializer)}`;
             }
+            // Shorthand: { name } → name: name
+            if (ts.isShorthandPropertyAssignment(p)) {
+                const name = visit(p.name);
+                return `${name}: ${name}`;
+            }
+            // Spread: { ...obj } — not easily supported in Go structs, omit
             return '';
         })
             .filter((p) => p)
@@ -555,9 +723,16 @@ export function visit(node, options = {}) {
     else if (ts.isNonNullExpression(node)) {
         return visit(node.expression);
     }
+    else if (ts.isImportDeclaration(node)) {
+        return visitImportDeclaration(node);
+    }
+    else if (ts.isExportDeclaration(node) || ts.isExportAssignment(node)) {
+        return '';
+    }
     const syntaxKind = ts.SyntaxKind[node.kind];
     if (!['FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
-        console.log(ts.SyntaxKind[node.kind], node.getText());
+        const snippet = node.getText().substring(0, 60).replace(/\n/g, ' ');
+        console.warn(`[TypeNative] Unsupported syntax: ${syntaxKind} — "${snippet}"`);
     }
     ts.forEachChild(node, (subNode) => {
         code += visit(subNode);
@@ -575,6 +750,34 @@ function getTypeText(typeNode) {
 function toGoStringLiteral(value) {
     return JSON.stringify(value);
 }
+function visitSpreadArrayLiteral(node, elemType) {
+    const chunks = [];
+    for (const el of node.elements) {
+        if (ts.isSpreadElement(el)) {
+            chunks.push({ isSpread: true, items: [el.expression] });
+        }
+        else {
+            const last = chunks[chunks.length - 1];
+            if (last && !last.isSpread) {
+                last.items.push(el);
+            }
+            else {
+                chunks.push({ isSpread: false, items: [el] });
+            }
+        }
+    }
+    const baseType = elemType || 'interface{}';
+    let result = `[]${baseType}{}`;
+    for (const chunk of chunks) {
+        if (chunk.isSpread) {
+            result = `append(${result}, ${visit(chunk.items[0])}...)`;
+        }
+        else {
+            result = `append(${result}, ${chunk.items.map((e) => visit(e)).join(', ')})`;
+        }
+    }
+    return result;
+}
 function visitTemplateExpression(node) {
     const parts = [];
     if (node.head.text.length > 0) {
@@ -656,9 +859,7 @@ function inferFunctionBodyReturnType(node) {
     return undefined;
 }
 function inferArrowFunctionGoType(node) {
-    const params = node.parameters
-        .map((p) => (p.type ? getType(p.type) : 'interface{}'))
-        .join(', ');
+    const params = node.parameters.map((p) => (p.type ? getType(p.type) : 'interface{}')).join(', ');
     const retType = inferFunctionBodyReturnType(node);
     return `func(${params})${retType ? ` ${retType}` : ''}`;
 }
@@ -937,8 +1138,8 @@ function buildArrayCallbackInfo(callback, elementType, forcedReturnType) {
             params.push(`${visit(callback.parameters[2].name)} []${elementType}`);
         }
         const body = ts.isBlock(callback.body)
-            ? visit(callback.body)
-            : `{\n\t\treturn ${visit(callback.body)};\n\t}`;
+            ? visit(callback.body, { inline: true })
+            : `{ return ${visit(callback.body)}; }`;
         return {
             fnExpr: `func(${params.join(', ')}) ${callbackReturnType} ${body}`,
             paramCount,
@@ -961,11 +1162,24 @@ function buildArrayCallbackInvocation(callbackInfo, itemVar, indexVar, arrayVar)
         args.push(arrayVar);
     return `(${callbackInfo.fnExpr})(${args.join(', ')})`;
 }
+// Like buildArrayCallbackInvocation but for reduce: (acc, item, idx, arr)
+function buildArrayCallbackInvocationReduce(callbackInfo, accVar, itemVar, indexVar, arrayVar) {
+    const args = [];
+    if (callbackInfo.paramCount > 0)
+        args.push(accVar);
+    if (callbackInfo.paramCount > 1)
+        args.push(itemVar);
+    if (callbackInfo.paramCount > 2)
+        args.push(`float64(${indexVar})`);
+    if (callbackInfo.paramCount > 3)
+        args.push(arrayVar);
+    return `(${callbackInfo.fnExpr})(${args.join(', ')})`;
+}
 function visitArrayHigherOrderCall(node) {
     if (!ts.isPropertyAccessExpression(node.expression))
         return undefined;
     const methodName = node.expression.name.text;
-    if (!['map', 'filter', 'some', 'find', 'join'].includes(methodName)) {
+    if (!['map', 'filter', 'some', 'find', 'findIndex', 'every', 'forEach', 'reduce', 'join'].includes(methodName)) {
         return undefined;
     }
     const arrayExprNode = node.expression.expression;
@@ -975,6 +1189,9 @@ function visitArrayHigherOrderCall(node) {
         ? getArrayElementTypeFromGoType(ownerType)
         : 'interface{}';
     if (methodName === 'join') {
+        // Only intercept array.join — if owner type is unknown/not array, fall through to callHandlers
+        if (!isArrayLikeGoType(ownerType))
+            return undefined;
         importedPackages.add('strings');
         importedPackages.add('fmt');
         const separator = node.arguments[0] ? visit(node.arguments[0]) : '""';
@@ -1010,6 +1227,43 @@ function visitArrayHigherOrderCall(node) {
         const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
         return `func() bool { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { return true } }; return false }()`;
     }
+    if (methodName === 'findIndex') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() float64 { ${arrVar} := ${arrayExpr}; for ${idxVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { return float64(${idxVar}) } }; return float64(-1) }()`;
+    }
+    if (methodName === 'every') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() bool { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if !(${callbackCall}) { return false } }; return true }()`;
+    }
+    if (methodName === 'forEach') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, '');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { ${callbackCall} } }()`;
+    }
+    if (methodName === 'reduce') {
+        const reduceCallback = node.arguments[0];
+        if (!reduceCallback)
+            return undefined;
+        const initialValue = node.arguments[1] ? visit(node.arguments[1]) : undefined;
+        const accType = initialValue
+            ? (inferExpressionType(node.arguments[1]) ?? elementType)
+            : elementType;
+        const accVar = getTempName('acc');
+        // Build a callback that takes (acc, item, idx, arr) — param count determines what gets passed
+        const cbInfo = buildArrayCallbackInfo(reduceCallback, elementType, accType ?? 'interface{}');
+        const cbCall = buildArrayCallbackInvocationReduce(cbInfo, accVar, itemVar, idxVar, arrVar);
+        // Only include the index loop var if the callback uses it (paramCount > 2)
+        const reduceIdxVar = cbInfo.paramCount > 2 ? idxVar : '_';
+        if (initialValue !== undefined) {
+            return `func() ${accType} { ${arrVar} := ${arrayExpr}; ${accVar} := ${initialValue}; for ${reduceIdxVar}, ${itemVar} := range ${arrVar} { ${accVar} = ${cbCall} }; return ${accVar} }()`;
+        }
+        return `func() ${elementType} { ${arrVar} := ${arrayExpr}; ${accVar} := ${arrVar}[0]; for ${reduceIdxVar}, ${itemVar} := range ${arrVar}[1:] { ${accVar} = ${cbCall} }; return ${accVar} }()`;
+    }
+    // find
     const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
     const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
     const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
@@ -1263,6 +1517,21 @@ function getAcessString(leftSide, rightSide, objectType) {
     if (rightSide === 'size' && (objectType === 'Map' || objectType === 'Set')) {
         return `float64(len(${leftSide}))`;
     }
+    // process global properties
+    if (leftSide === 'process') {
+        if (rightSide === 'argv') {
+            importedPackages.add('os');
+            return 'os.Args';
+        }
+        if (rightSide === 'platform') {
+            importedPackages.add('runtime');
+            return 'runtime.GOOS';
+        }
+        if (rightSide === 'env') {
+            // process.env.X is handled by nested property access; just return a placeholder object
+            return 'os.Environ()';
+        }
+    }
     return `${leftSide}.${rightSide}`;
 }
 const callHandlers = {
@@ -1326,7 +1595,84 @@ const callHandlers = {
     parseFloat: (_caller, args) => {
         importedPackages.add('strconv');
         return `func() float64 { v, _ := strconv.ParseFloat(${args[0]}, 64); return v }()`;
-    }
+    },
+    'process.exit': (_caller, args) => {
+        importedPackages.add('os');
+        return `os.Exit(int(${args[0] ?? '0'}))`;
+    },
+    'process.cwd': () => {
+        importedPackages.add('os');
+        return `func() string { __d, _ := os.Getwd(); return __d }()`;
+    },
+    'JSON.stringify': (_caller, args) => {
+        importedPackages.add('encoding/json');
+        if (args.length >= 3) {
+            return `func() string { __b, _ := json.MarshalIndent(${args[0]}, "", "  "); return string(__b) }()`;
+        }
+        return `func() string { __b, _ := json.Marshal(${args[0]}); return string(__b) }()`;
+    },
+    'JSON.parse': (_caller, args) => {
+        importedPackages.add('encoding/json');
+        return `func() interface{} { var __v interface{}; json.Unmarshal([]byte(${args[0]}), &__v); return __v }()`;
+    },
+    'Object.keys': (_caller, args) => {
+        importedPackages.add('maps');
+        return `func() []string { __k := make([]string, 0); for k := range ${args[0]} { __k = append(__k, k) }; return __k }()`;
+    },
+    'Object.values': (_caller, args) => {
+        return `func() []interface{} { __v := make([]interface{}, 0); for _, v := range ${args[0]} { __v = append(__v, v) }; return __v }()`;
+    },
+    'Object.entries': (_caller, args) => {
+        // When used outside for...of, produce a slice of [key, value] pairs — rarely needed
+        return args[0];
+    },
+    'Math.log': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Log(${args[0]})`;
+    },
+    'Math.log2': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Log2(${args[0]})`;
+    },
+    'Math.log10': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Log10(${args[0]})`;
+    },
+    'Math.sin': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Sin(${args[0]})`;
+    },
+    'Math.cos': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Cos(${args[0]})`;
+    },
+    'Math.tan': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Tan(${args[0]})`;
+    },
+    'Math.trunc': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Trunc(${args[0]})`;
+    },
+    'Math.sign': (_caller, args) => {
+        return `func() float64 { if ${args[0]} > 0 { return 1 }; if ${args[0]} < 0 { return -1 }; return 0 }()`;
+    },
+    'console.error': (_caller, args) => {
+        importedPackages.add('fmt');
+        importedPackages.add('os');
+        return `fmt.Fprintln(os.Stderr, ${args.join(', ')})`;
+    },
+    'String': (_caller, args) => {
+        importedPackages.add('fmt');
+        return `fmt.Sprintf("%v", ${args[0]})`;
+    },
+    'Number': (_caller, args) => {
+        importedPackages.add('strconv');
+        return `func() float64 { v, _ := strconv.ParseFloat(fmt.Sprintf("%v", ${args[0]}), 64); return v }()`;
+    },
+    'Boolean': (_caller, args) => {
+        return `(${args[0]} != nil && ${args[0]} != false && ${args[0]} != 0 && ${args[0]} != "")`;
+    },
 };
 const stringMethodHandlers = {
     split: (obj, args) => {
@@ -1393,6 +1739,32 @@ const stringMethodHandlers = {
         return `${obj}[int(${args[0]}):]`;
     },
     concat: (obj, args) => `${obj} + ${args.join(' + ')}`,
+    padStart: (obj, args) => {
+        importedPackages.add('fmt');
+        importedPackages.add('strings');
+        const pad = args[1] ?? '" "';
+        return `func() string { __s := ${obj}; __n := int(${args[0]}) - len(__s); if __n > 0 { __s = strings.Repeat(${pad}, __n)[:__n] + __s }; return __s }()`;
+    },
+    padEnd: (obj, args) => {
+        importedPackages.add('strings');
+        const pad = args[1] ?? '" "';
+        return `func() string { __s := ${obj}; __n := int(${args[0]}) - len(__s); if __n > 0 { __s = __s + strings.Repeat(${pad}, __n)[:__n] }; return __s }()`;
+    },
+    match: (obj, args) => {
+        importedPackages.add('regexp');
+        return `regexp.MustCompile(${args[0]}).FindStringSubmatch(${obj})`;
+    },
+    matchAll: (obj, args) => {
+        importedPackages.add('regexp');
+        return `regexp.MustCompile(${args[0]}).FindAllStringSubmatch(${obj}, -1)`;
+    },
+    search: (obj, args) => {
+        importedPackages.add('regexp');
+        return `float64(regexp.MustCompile(${args[0]}).FindStringIndex(${obj})[0])`;
+    },
+    at: (obj, args) => {
+        return `func() string { __i := int(${args[0]}); if __i < 0 { __i = len(${obj}) + __i }; return string(${obj}[__i]) }()`;
+    },
     toString: (obj) => {
         importedPackages.add('fmt');
         return `fmt.Sprintf("%v", ${obj})`;
@@ -1404,6 +1776,13 @@ const regexpMethodHandlers = {
 };
 const arrayMethodHandlers = {
     push: (obj, args) => `${obj} = append(${obj}, ${args.join(', ')})`,
+    pop: (obj) => {
+        return `func() interface{} { if len(${obj}) == 0 { return nil }; __last := ${obj}[len(${obj})-1]; ${obj} = ${obj}[:len(${obj})-1]; return __last }()`;
+    },
+    shift: (obj) => {
+        return `func() interface{} { if len(${obj}) == 0 { return nil }; __first := ${obj}[0]; ${obj} = ${obj}[1:]; return __first }()`;
+    },
+    unshift: (obj, args) => `${obj} = append([]interface{}{${args.join(', ')}}, ${obj}...)`,
     join: (obj, args) => {
         importedPackages.add('strings');
         return `strings.Join(${obj}, ${args[0] ?? '""'})`;
@@ -1413,10 +1792,30 @@ const arrayMethodHandlers = {
             return `${obj}[int(${args[0]}):int(${args[1]})]`;
         return `${obj}[int(${args[0]}):]`;
     },
+    reverse: (obj) => {
+        importedPackages.add('slices');
+        return `func() interface{} { slices.Reverse(${obj}); return nil }()`;
+    },
+    sort: (obj) => {
+        importedPackages.add('sort');
+        return `func() interface{} { sort.Slice(${obj}, func(i, j int) bool { return fmt.Sprintf("%v", ${obj}[i]) < fmt.Sprintf("%v", ${obj}[j]) }); return nil }()`;
+    },
+    indexOf: (obj, args) => {
+        return `func() float64 { for __i, __v := range ${obj} { if fmt.Sprintf("%v", __v) == fmt.Sprintf("%v", ${args[0]}) { return float64(__i) } }; return float64(-1) }()`;
+    },
+    includes: (obj, args) => {
+        return `func() bool { for _, __v := range ${obj} { if fmt.Sprintf("%v", __v) == fmt.Sprintf("%v", ${args[0]}) { return true } }; return false }()`;
+    },
+    concat: (obj, args) => `append(${obj}, ${args.join(', ')}...)`,
+    flat: (obj) => obj,
     toString: (obj) => {
         importedPackages.add('fmt');
         return `fmt.Sprintf("%v", ${obj})`;
-    }
+    },
+    // padStart / padEnd for string arrays (rarely used, but added for completeness)
+    at: (obj, args) => {
+        return `func() interface{} { __i := int(${args[0]}); if __i < 0 { __i = len(${obj}) + __i }; if __i < 0 || __i >= len(${obj}) { return nil }; return ${obj}[__i] }()`;
+    },
 };
 const mapMethodHandlers = {
     set: (obj, args) => `${obj}[${args[0]}] = ${args[1]}`,
@@ -1549,6 +1948,17 @@ function getTypeArguments(typeArguments) {
     return `[${args.join(', ')}]`;
 }
 function getParameterGoType(param) {
+    // Rest parameter: ...args — use variadic syntax
+    if (param.dotDotDotToken) {
+        if (param.type) {
+            let baseType = getType(param.type);
+            // If annotated as T[], the variadic type is T
+            if (baseType.startsWith('[]'))
+                baseType = baseType.slice(2);
+            return `...${baseType}`;
+        }
+        return '...interface{}';
+    }
     if (param.type) {
         const explicitType = getType(param.type);
         return explicitType === ':' ? 'interface{}' : explicitType;
@@ -1572,9 +1982,7 @@ function getFunctionParametersInfo(parameters) {
             prefixBlockContent: ''
         };
     }
-    const hasRequiredAfterDefault = parameters
-        .slice(firstDefaultIndex)
-        .some((p) => !p.initializer);
+    const hasRequiredAfterDefault = parameters.slice(firstDefaultIndex).some((p) => !p.initializer);
     if (hasRequiredAfterDefault) {
         return {
             signature: parameters.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`).join(', '),
@@ -1714,6 +2122,230 @@ function visitNewSet(node) {
     const values = initArg.elements.map((el) => `${tmp}[${visit(el)}] = struct{}{}`).join('; ');
     return `func() ${setType} { ${tmp} := make(${setType}); ${values}; return ${tmp} }()`;
 }
+function specifierToGoFileName(specifier) {
+    const segments = specifier.split(/[/\\]/);
+    let name = segments[segments.length - 1] || segments[segments.length - 2] || 'import';
+    // Strip all extensions (e.g. .spec.ts → '', .ts → '')
+    name = name.replace(/(\.[^.]+)+$/, '');
+    name = name.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+    if (!name)
+        name = 'import';
+    // Deduplicate filename if already taken by a different import
+    let candidate = name + '.go';
+    let i = 2;
+    while (localImportFiles.has(candidate)) {
+        candidate = `${name}_${i}.go`;
+        i++;
+    }
+    return candidate;
+}
+function normalizeCjsToEsm(code) {
+    // Remove 'use strict' directive
+    code = code.replace(/['"]use strict['"];?\n?/g, '');
+    // module.exports.X = function(...) { } or exports.X = function(...) { }
+    code = code.replace(/(?:module\.exports|exports)\.(\w+)\s*=\s*function\s*\w*\s*\(/g, 'export function $1(');
+    return code;
+}
+function includeLocalImport(code, dir, goFileName) {
+    const prevDir = currentFileDir;
+    currentFileDir = dir;
+    // Normalize CommonJS modules to ES module syntax before parsing
+    if (!code.includes('export ') && (code.includes('module.exports') || code.includes('exports.'))) {
+        code = normalizeCjsToEsm(code);
+    }
+    if (!goFileName) {
+        // Inline mode (npm packages): pull declarations into the current transpilation context
+        const sf = ts.createSourceFile('imported.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+        for (const stmt of sf.statements) {
+            visit(stmt, { addFunctionOutside: true });
+        }
+        currentFileDir = prevDir;
+        return;
+    }
+    // Separate-file mode (local TS imports): transpile to its own Go file
+    const savedOutsideNodes = outsideNodes;
+    const savedPackages = [...importedPackages];
+    outsideNodes = [];
+    importedPackages.clear();
+    const sf = ts.createSourceFile('imported.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    const inlineLines = [];
+    for (const stmt of sf.statements) {
+        const result = visit(stmt, { addFunctionOutside: true });
+        if (result.trim())
+            inlineLines.push(result);
+    }
+    const fileImports = [...importedPackages].map((pkg) => `import "${pkg}"`).join('\n');
+    const fileOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
+    const fileInline = inlineLines.join('\n');
+    const parts = ['package main'];
+    if (fileImports)
+        parts.push(fileImports);
+    if (fileInline.trim())
+        parts.push(fileInline.trim());
+    if (fileOutside.trim())
+        parts.push(fileOutside.trim());
+    localImportFiles.set(goFileName, parts.join('\n\n'));
+    // Restore main-file state
+    outsideNodes = savedOutsideNodes;
+    importedPackages.clear();
+    for (const p of savedPackages)
+        importedPackages.add(p);
+    currentFileDir = prevDir;
+}
+function registerGoPackageAliases(node, goPkg) {
+    const pkgName = goPkg.split('/').pop();
+    if (!node.importClause)
+        return;
+    const clause = node.importClause;
+    // Default import: `import fmt from 'go:fmt'` or `import myFmt from 'go:fmt'`
+    if (clause.name && clause.name.text !== pkgName) {
+        importAliases.set(clause.name.text, pkgName);
+    }
+    if (clause.namedBindings) {
+        if (ts.isNamespaceImport(clause.namedBindings)) {
+            // `import * as myFmt from 'go:fmt'`
+            const localName = clause.namedBindings.name.text;
+            if (localName !== pkgName) {
+                importAliases.set(localName, pkgName);
+            }
+        }
+        else if (ts.isNamedImports(clause.namedBindings)) {
+            // `import { Println, Sprintf as Spf } from 'go:fmt'`
+            for (const el of clause.namedBindings.elements) {
+                if (el.isTypeOnly)
+                    continue;
+                const localName = el.name.text;
+                const importedName = el.propertyName?.text ?? localName;
+                importAliases.set(localName, `${pkgName}.${importedName}`);
+            }
+        }
+    }
+}
+function getImportLocalName(node) {
+    const clause = node.importClause;
+    if (!clause)
+        return null;
+    if (clause.name)
+        return clause.name.text;
+    if (clause.namedBindings) {
+        if (ts.isNamespaceImport(clause.namedBindings))
+            return clause.namedBindings.name.text;
+    }
+    return null;
+}
+// Per-module table: maps Node.js function name → Go expression template.
+// For default/namespace imports (e.g. `import path from 'node:path'`), entries are registered
+// as `callHandlers[localName.funcName]`. For named imports (e.g. `import { join } from 'node:path'`),
+// the Go identifier is stored in importAliases so bare calls like `join(...)` resolve correctly.
+const nodeModuleMappings = {
+    path: {
+        goPackage: 'path/filepath',
+        functions: {
+            join: (args) => `filepath.Join(${args.join(', ')})`,
+            dirname: (args) => `filepath.Dir(${args[0]})`,
+            basename: (args) => args[1]
+                ? `strings.TrimSuffix(filepath.Base(${args[0]}), ${args[1]})`
+                : `filepath.Base(${args[0]})`,
+            extname: (args) => `filepath.Ext(${args[0]})`,
+            resolve: (args) => `func() string { p, _ := filepath.Abs(filepath.Join(${args.join(', ')})); return p }()`
+        }
+    }
+    // Future node stdlib modules can be added here as additional keys:
+    // fs: { goPackage: 'os', functions: { ... } },
+    // os: { goPackage: 'os', functions: { ... } },
+};
+// Mapping from Node.js stdlib module names to Go setup functions.
+// Each entry adds the required Go imports and registers call handlers for the local identifier.
+function setupNodeModuleImport(node, nodeModule) {
+    const mapping = nodeModuleMappings[nodeModule];
+    if (!mapping)
+        return;
+    importedPackages.add(mapping.goPackage);
+    const clause = node.importClause;
+    if (!clause)
+        return;
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+        // Named imports: `import { join, dirname } from 'node:path'`
+        // Map each local name directly to its Go qualified function via importAliases,
+        // so bare calls like `join(...)` resolve to `filepath.Join(...)`.
+        for (const el of clause.namedBindings.elements) {
+            if (el.isTypeOnly)
+                continue;
+            const localName = el.name.text;
+            const importedName = el.propertyName?.text ?? localName;
+            const fn = mapping.functions[importedName];
+            if (fn) {
+                // Register a call handler keyed on the local name
+                callHandlers[localName] = (_caller, args) => fn(args);
+            }
+        }
+    }
+    else {
+        // Default import (`import path from 'node:path'`) or
+        // namespace import (`import * as path from 'node:path'`)
+        const localName = getImportLocalName(node) ?? nodeModule;
+        for (const [funcName, fn] of Object.entries(mapping.functions)) {
+            callHandlers[`${localName}.${funcName}`] = (_caller, args) => fn(args);
+        }
+    }
+}
+function visitImportDeclaration(node) {
+    if (!ts.isStringLiteral(node.moduleSpecifier))
+        return '';
+    const moduleSpec = node.moduleSpecifier.text;
+    // Relative imports → transpile to a separate Go file
+    if (moduleSpec.startsWith('.') || moduleSpec.startsWith('/')) {
+        // Key combines current dir + specifier to avoid cross-package collisions
+        const key = `${currentFileDir ?? ''}::${moduleSpec}`;
+        if (fileResolver && !includedLocalImports.has(key)) {
+            includedLocalImports.add(key);
+            const resolved = fileResolver(moduleSpec, currentFileDir);
+            if (resolved) {
+                const goFileName = specifierToGoFileName(moduleSpec);
+                includeLocalImport(resolved.content, resolved.dir, goFileName);
+            }
+        }
+        return '';
+    }
+    // Type-only imports contribute nothing to runtime
+    if (node.importClause?.isTypeOnly)
+        return '';
+    // Go standard library: `import { Println } from 'go:fmt'` → import "fmt"
+    if (moduleSpec.startsWith('go:')) {
+        const goPkg = moduleSpec.slice(3);
+        importedPackages.add(goPkg);
+        registerGoPackageAliases(node, goPkg);
+        return '';
+    }
+    // Node.js standard library: `import path from 'node:path'` → mapped Go packages
+    if (moduleSpec.startsWith('node:')) {
+        const nodeModule = moduleSpec.slice(5);
+        setupNodeModuleImport(node, nodeModule);
+        return '';
+    }
+    // npm package (bare specifier) → transpile to its own Go file
+    const npmKey = `npm::${moduleSpec}`;
+    if (fileResolver && !includedLocalImports.has(npmKey)) {
+        includedLocalImports.add(npmKey);
+        const resolved = fileResolver(moduleSpec, currentFileDir);
+        if (resolved) {
+            const goFileName = specifierToGoFileName(moduleSpec);
+            includeLocalImport(resolved.content, resolved.dir, goFileName);
+        }
+    }
+    // Register default/namespace import name as a "stripped" namespace
+    // e.g. `import ts from 'typescript'` → ts.createSourceFile → createSourceFile
+    if (node.importClause) {
+        const clause = node.importClause;
+        if (clause.name) {
+            defaultImportNamespaces.add(clause.name.text);
+        }
+        else if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+            defaultImportNamespaces.add(clause.namedBindings.name.text);
+        }
+    }
+    return '';
+}
 function getForOfVarNames(initializer) {
     if (!ts.isVariableDeclarationList(initializer) || initializer.declarations.length === 0) {
         return ['_'];