typenative 0.0.15 → 0.0.17

package/CHANGELOG.md

@@ -5,28 +5,77 @@ All notable changes to TypeNative will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.17] - 2026-02-16
+
+### Added
+
+- Support for ternary expressions (`condition ? a : b`)
+- Support for optional chaining (`obj?.prop`, `arr?.[i]`)
+- Support for nullish coalescing (`??` operator)
+- Support for type aliases (`type X = ...`)
+- Support for type assertions (`expr as Type`)
+- Support for optional properties (`prop?: Type` in interfaces/types)
+- Support for default parameter values (e.g. `function(x = defaultValue)`)
+- Support for enum declarations and member access (`enum X { ... }`, `X.Member`)
+- Support for array methods: `map`, `filter`, `some`, `find`
+- Support for chaining array methods (e.g. `arr.map(...).filter(...).join(...)`)
+
+## [0.0.16] - 2025-02-15
+
+### Added
+
+- RegExp support: regex literals (`/pattern/flags`), `new RegExp()`, `test()`, and `exec()` mapped to Go's `regexp` package
+- Universal `toString()` support for numbers, booleans, arrays, and objects
+
+## [0.0.15] - 2025-02-15
+
+### Added
+
+- Classes with constructors, inheritance (`extends`, `super()`), and methods transpiled to Go structs
+- Interfaces with method signatures and `extends` transpiled to Go interfaces
+- Generics support for functions and classes via Go type parameters
+- Async/Await transpiled to Go channels and goroutines
+- Promises (`new Promise`) transpiled to channel + goroutine pattern
+- `setTimeout` mapped to Go's `time.AfterFunc`
+- Nullable types (`T | null`, `T | undefined`) transpiled to Go pointer types
+- Object literals transpiled to Go struct literals
+- `assert()` function transpiled to `panic` on failure
+- `parseInt` and `parseFloat` mapped to Go's `strconv` package
+- String methods: `split`, `trim`, `trimStart`, `trimEnd`, `toUpperCase`, `toLowerCase`, `indexOf`, `includes`, `startsWith`, `endsWith`, `replace`, `replaceAll`, `repeat`, `charAt`, `substring`, `slice`, `concat`, `toString`
+- Array methods: `join`, `slice`, `toString` (in addition to existing `push`)
+- Math methods: `ceil`, `round`, `abs`, `sqrt`, `pow`, `min`, `max` (in addition to existing `random`, `floor`)
+- Non-null assertion operator (`!`) support
+- Type-aware method dispatch to prevent class methods from being intercepted as built-in string/array methods
+- Safe name collision avoidance for Go reserved identifiers
+- Automatic Go import management for `fmt`, `math`, `math/rand`, `strings`, `strconv`, `time`
+
 ## [0.0.14] - 2025-05-25
 
 ### Added
+
 - Project creation with new `--new` command
 - Support for functions and arrow functions
 - Support for switch statements
 - If statements, while loops, and for...of loops for arrays
 
 ### Changed
+
 - Replaced shelljs dependency with execa for improved process execution
 
 ### Fixed
+
 - Project creation issues
 
 ## [0.0.12] - 2025-05-23
 
 ### Changed
+
 - Switched transpilation target to Go language
 
 ## [0.0.9] - 2024-03-01
 
 ### Added
+
 - Basic types support (number, boolean, string, null, any)
 - Support for variable declarations
 - Support for binary expressions
@@ -35,10 +84,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.0.1] - 2024-02-24
 
 ### Added
+
 - Initial project setup
 - Basic project structure
 
 ## [0.0.0] - 2022-12-20
 
 ### Added
+
 - Initial commit

package/README.md

@@ -11,55 +11,142 @@ Build native applications using Typescript.
 
 - Write a file `test.ts` with content `console.log('Hello World!');` or any other message
 - Run `npx typenative --source test.ts --script`
-- See your message in the terminal
 
-## Create a TypeNative Project
+## Typescript Syntax Support
 
-- Run `npx typenative --new`
-- Give your project a name
-- Start writing code
+TypeNative currently supports a focused subset of TypeScript syntax elements that are transpiled to Go code. The support is grouped by topic for easier scanning.
 
-## Typescript Syntax Support
+**Basic Types**
+
+| Feature        | Supported | Notes                                                         |
+| -------------- | :-------: | ------------------------------------------------------------- |
+| number         |    ✅     | Transpiled to `float64`                                       |
+| boolean        |    ✅     | Transpiled to `bool`                                          |
+| string         |    ✅     |                                                               |
+| null           |    ✅     |                                                               |
+| any            |    ✅     | Used for type inference                                       |
+| Nullable types |    ✅     | `T \| null` / `T \| undefined` transpiled to Go pointer types |
+
+**Variables & Objects**
+
+| Feature               | Supported | Notes                            |
+| --------------------- | :-------: | -------------------------------- |
+| Variable declarations |    ✅     | `let` and `const`                |
+| Object literals       |    ✅     | Transpiled to Go struct literals |
+
+**Operators**
+
+| Feature                  | Supported | Notes                          |
+| ------------------------ | :-------: | ------------------------------ |
+| Arithmetic operators     |    ✅     | `+`, `-`, etc.                 |
+| Comparison operators     |    ✅     | `==`, `!=`, `===`, `!==`, etc. |
+| Logical operators        |    ✅     | `&&`, `\|\|`                   |
+| Increment/Decrement      |    ✅     | `++`, `--`                     |
+| Non-null assertion (`!`) |    ✅     | Stripped during transpilation  |
+| Ternary expressions      |    ✅     | `condition ? a : b`            |
+| Nullish coalescing       |    ✅     | `??` operator                  |
+| Optional chaining        |    ✅     | `obj?.prop`, `arr?.[i]`        |
+
+**Control Flow**
+
+| Feature            | Supported | Notes                              |
+| ------------------ | :-------: | ---------------------------------- |
+| If/Else statements |    ✅     | Fully supported                    |
+| Switch statements  |    ✅     | Case and default statements        |
+| For loops          |    ✅     | Standard `for` loops               |
+| For...of loops     |    ✅     | Iteration over arrays              |
+| While loops        |    ✅     | Transpiled to Go's `for` loops     |
+| Do...while loops   |    ✅     | Implemented with conditional break |
+
+**Data Structures & Array Methods**
+
+| Feature                    | Supported | Notes                                                            |
+| -------------------------- | :-------: | ---------------------------------------------------------------- |
+| Arrays                     |    ✅     | Basic array operations                                           |
+| Array methods              |    ✅     | `push`, `join`, `slice`                                          |
+| Higher-order array methods |    ✅     | `.map()`, `.filter()`, `.some()`, `.find()`                      |
+| Method chaining            |    ✅     | Chaining array methods such as `.map(...).filter(...).join(...)` |
+
+**Functions**
+
+| Feature                      | Supported | Notes                             |
+| ---------------------------- | :-------: | --------------------------------- |
+| Function declarations        |    ✅     | Transpiled to Go functions        |
+| Arrow functions              |    ✅     | Transpiled to anonymous functions |
+| Generics (functions/classes) |    ✅     | Type parameters via Go generics   |
+| Default parameter values     |    ✅     | `function(x = defaultValue)`      |
+
+**Classes & Interfaces**
+
+| Feature             | Supported | Notes                                                          |
+| ------------------- | :-------: | -------------------------------------------------------------- |
+| Classes             |    ✅     | Transpiled to Go structs with constructor and receiver methods |
+| Class inheritance   |    ✅     | `extends` via embedded structs, `super()` supported            |
+| Interfaces          |    ✅     | Transpiled to Go interfaces, supports `extends`                |
+| Optional properties |    ✅     | `prop?: Type` in interfaces/types                              |
+| Enums               |    ✅     | `enum` declarations and member access                          |
+
+**Async & Timing**
+
+| Feature     | Supported | Notes                                                             |
+| ----------- | :-------: | ----------------------------------------------------------------- |
+| Async/Await |    ✅     | `async` functions return Go channels, `await` reads from channels |
+| Promises    |    ✅     | `new Promise` transpiled to channel + goroutine pattern           |
+| setTimeout  |    ✅     | Mapped to Go's `time.AfterFunc`                                   |
+
+**Built-in Functions & Utilities**
+
+| Feature               | Supported | Notes                                                 |
+| --------------------- | :-------: | ----------------------------------------------------- |
+| console.log           |    ✅     | Mapped to `fmt.Println`                               |
+| console.time/timeEnd  |    ✅     | Performance measurement via `time.Now` / `time.Since` |
+| assert                |    ✅     | Transpiled to `panic` on failure                      |
+| parseInt / parseFloat |    ✅     | Mapped to Go's `strconv` package                      |
+
+**Math Methods**
+
+| Feature                   | Supported | Notes                                             |
+| ------------------------- | :-------: | ------------------------------------------------- |
+| Math.random               |    ✅     | Mapped to `rand.Float64()`                        |
+| Math.floor / ceil / round |    ✅     | Mapped to `math.Floor`, `math.Ceil`, `math.Round` |
+| Math.abs / sqrt / pow     |    ✅     | Mapped to corresponding `math` functions          |
+| Math.min / max            |    ✅     | Mapped to `math.Min`, `math.Max`                  |
+
+**String Methods**
+
+| Feature                    | Supported | Notes                                         |
+| -------------------------- | :-------: | --------------------------------------------- |
+| Template literals          |    ✅     | Backtick strings with `${expr}` interpolation |
+| toUpperCase / toLowerCase  |    ✅     | Via `strings` package                         |
+| trim / trimStart / trimEnd |    ✅     | Via `strings` package                         |
+| split / includes / indexOf |    ✅     | Via `strings` package                         |
+| startsWith / endsWith      |    ✅     | Via `strings` package                         |
+| replace / replaceAll       |    ✅     | Via `strings` package                         |
+| charAt / substring / slice |    ✅     | Direct Go string indexing/slicing             |
+| concat / repeat            |    ✅     | String concatenation and `strings.Repeat`     |
+
+**Number / Object Methods**
+
+| Feature  | Supported | Notes                                                 |
+| -------- | :-------: | ----------------------------------------------------- |
+| toString |    ✅     | Universal `toString()` via `fmt.Sprintf` for any type |
+
+**RegExp**
+
+| Feature        | Supported | Notes                                               |
+| -------------- | :-------: | --------------------------------------------------- |
+| Regex literals |    ✅     | `/pattern/flags` transpiled to `regexp.MustCompile` |
+| new RegExp()   |    ✅     | Constructor with optional flags                     |
+| test()         |    ✅     | Mapped to `regexp.MatchString`                      |
+| exec()         |    ✅     | Mapped to `regexp.FindStringSubmatch`               |
+
+**Unsupported / Roadmap**
+
+| Feature                     | Supported | Notes                                            |
+| --------------------------- | :-------: | ------------------------------------------------ |
+| Modules/Imports             |    ❌     | `import` / `export` declarations                 |
+| Try/Catch                   |    ❌     | Error handling                                   |
+| Map / Set                   |    ❌     | Built-in collection types and their methods      |
+| Closures over mutable state |    ❌     | Functions capturing and mutating outer variables |
 
-TypeNative currently supports a subset of TypeScript syntax elements that are transpiled to Go code:
-
-| Feature | Supported | Notes |
-|---------|:---------:|-------|
-| **Basic Types** |  |  |
-| number | ✅ | Transpiled to `float64` |
-| boolean | ✅ | Transpiled to `bool` |
-| string | ✅ | |
-| null | ✅ |  |
-| any | ✅ | Used for type inference |
-| **Variables** |  |  |
-| Variable declarations | ✅ | `let` and `const` |
-| **Operators** |  |  |
-| Arithmetic operators | ✅ | `+`, `-`, etc. |
-| Comparison operators | ✅ | `==`, `!=`, etc. |
-| Logical operators | ✅ | `&&`, `\|\|` |
-| Increment/Decrement | ✅ | `++`, `--` |
-| **Control Flow** |  |  |
-| For loops | ✅ | Standard `for` loops |
-| For...of loops | ✅ | Iteration over arrays |
-| While loops | ✅ | Transpiled to Go's `for` loops |
-| Do...while loops | ✅ | Implemented with conditional break |
-| If/Else statements | ✅ | Fully supported |
-| Switch statements | ✅ | Case and default statements |
-| **Data Structures** |  |  |
-| Arrays | ✅ | Basic array operations |
-| Array methods | ✅ | `push` supported |
-| **Functions** |  |  |
-| Function declarations | ✅ | Transpiled to Go functions |
-| Arrow Functions | ✅ | Transpiled to anonymous functions |
-| console.log | ✅ | Mapped to `fmt.Println` |
-| console.time/timeEnd | ✅ | Performance measurement |
-| Math.random | ✅ | Mapped to Go's `rand.Float64()` |
-| Math.floor | ✅ | Mapped to Go's `math.Floor()` |
-| **Unsupported Features** |  |  |
-| Classes | ❌ | Not implemented |
-| Interfaces | ❌ | Not implemented |
-| Async/Await | ❌ | Not implemented |
-| Modules/Imports | ❌ | Not implemented |
-| Generics | ❌ | Not implemented |
-
-TypeNative is currently in early development and new features are being added regularly.
+TypeNative is currently in early development and new features are being added regularly. The goal for `1.0` release is for TypeNative to transpile itself.

package/bin/index.js

@@ -105,7 +105,7 @@ function getPackageJson(projectName) {
             build: `npx typenative --source main.ts --output bin/${projectName}.exe`
         },
         devDependencies: {
-            typenative: '^0.0.15'
+            typenative: '^0.0.16'
         }
     };
     return JSON.stringify(pckg, null, 2);

package/bin/transpiler.js

@@ -9,6 +9,14 @@ let promiseResolveName = '';
 const dangerousNames = new Set(['main']);
 const renamedFunctions = new Map();
 const variableTypes = new Map();
+const variableGoTypes = new Map();
+const variableClassNames = new Map();
+const classPropertyTypes = new Map();
+const classMethodReturnTypes = new Map();
+const interfacePropertyTypes = new Map();
+const typeAliases = new Map();
+const enumNames = new Set();
+const enumBaseTypes = new Map();
 export function transpileToNative(code) {
     const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
     TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
@@ -18,6 +26,14 @@ export function transpileToNative(code) {
     promiseResolveName = '';
     renamedFunctions.clear();
     variableTypes.clear();
+    variableGoTypes.clear();
+    variableClassNames.clear();
+    classPropertyTypes.clear();
+    classMethodReturnTypes.clear();
+    interfacePropertyTypes.clear();
+    typeAliases.clear();
+    enumNames.clear();
+    enumBaseTypes.clear();
     const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
     const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
     return `package main
@@ -43,8 +59,17 @@ export function visit(node, options = {}) {
             return 'nil';
         return getSafeName(node.text);
     }
-    else if (ts.isStringLiteral(node)) {
-        return `"${node.text}"`;
+    else if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return toGoStringLiteral(node.text);
+    }
+    else if (ts.isAsExpression(node)) {
+        return visit(node.expression);
+    }
+    else if (ts.isTypeAssertionExpression(node)) {
+        return visit(node.expression);
+    }
+    else if (ts.isTemplateExpression(node)) {
+        return visitTemplateExpression(node);
     }
     else if (ts.isNumericLiteral(node)) {
         return `float64(${node.text})`;
@@ -58,17 +83,38 @@ export function visit(node, options = {}) {
     else if (ts.isToken(node) && node.kind === ts.SyntaxKind.NullKeyword) {
         return `nil`;
     }
+    else if (ts.isRegularExpressionLiteral(node)) {
+        importedPackages.add('regexp');
+        const text = node.text; // e.g. /pattern/flags
+        const lastSlash = text.lastIndexOf('/');
+        const pattern = text.substring(1, lastSlash);
+        const flags = text.substring(lastSlash + 1);
+        const goFlags = jsRegexFlagsToGo(flags);
+        const escaped = pattern.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        return `regexp.MustCompile("${goFlags}${escaped}")`;
+    }
     else if (ts.isArrayLiteralExpression(node)) {
         const type = ts.isVariableDeclaration(node.parent) ? getType(node.parent.type, true) : '';
         return `[]${type} {${node.elements.map((e) => visit(e)).join(', ')}}`;
     }
     else if (ts.isBlock(node)) {
-        return `{\n\t\t${node.statements.map((n) => visit(n)).join('\t')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
+        return `{\n\t\t${options.prefixBlockContent ?? ''}${node.statements
+            .map((n) => visit(n))
+            .join('\t')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
     }
     else if (ts.isElementAccessExpression(node)) {
+        if (hasQuestionDot(node)) {
+            return visitOptionalElementAccess(node);
+        }
         return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
     }
     else if (ts.isPropertyAccessExpression(node)) {
+        if (hasQuestionDot(node)) {
+            return visitOptionalPropertyAccess(node);
+        }
+        if (ts.isIdentifier(node.expression) && enumNames.has(node.expression.text)) {
+            return `${getSafeName(node.expression.text)}_${getEnumMemberName(node.name)}`;
+        }
         const leftSide = visit(node.expression);
         const rightSide = visit(node.name);
         const objectType = resolveExpressionType(node.expression);
@@ -78,15 +124,37 @@ export function visit(node, options = {}) {
         const type = getType(node.type);
         // Track variable type for type-aware method dispatch
         if (ts.isIdentifier(node.name)) {
+            if (node.type) {
+                variableGoTypes.set(node.name.text, getType(node.type));
+            }
             const cat = node.type ? getTypeCategory(node.type) : undefined;
             if (cat) {
                 variableTypes.set(node.name.text, cat);
+                if (cat === 'class' && node.type) {
+                    const className = getClassNameFromTypeNode(node.type);
+                    if (className) {
+                        variableClassNames.set(node.name.text, className);
+                    }
+                }
             }
             else if (node.initializer &&
                 ts.isNewExpression(node.initializer) &&
                 ts.isIdentifier(node.initializer.expression)) {
-                if (classNames.has(node.initializer.expression.text)) {
+                if (node.initializer.expression.text === 'RegExp') {
+                    variableTypes.set(node.name.text, 'RegExp');
+                }
+                else if (classNames.has(node.initializer.expression.text)) {
                     variableTypes.set(node.name.text, 'class');
+                    variableClassNames.set(node.name.text, node.initializer.expression.text);
+                }
+            }
+            else if (node.initializer && ts.isRegularExpressionLiteral(node.initializer)) {
+                variableTypes.set(node.name.text, 'RegExp');
+            }
+            if (!variableGoTypes.has(node.name.text) && node.initializer) {
+                const inferredType = inferExpressionType(node.initializer);
+                if (inferredType) {
+                    variableGoTypes.set(node.name.text, inferredType);
                 }
             }
         }
@@ -103,6 +171,10 @@ export function visit(node, options = {}) {
         return `${type === ':' ? '' : 'var '}${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
     }
     else if (ts.isCallExpression(node)) {
+        if (hasQuestionDot(node) ||
+            (ts.isPropertyAccessExpression(node.expression) && hasQuestionDot(node.expression))) {
+            return visitOptionalCall(node);
+        }
         // Handle setTimeout specially to get raw delay value
         if (ts.isIdentifier(node.expression) && node.expression.text === 'setTimeout') {
             importedPackages.add('time');
@@ -111,6 +183,10 @@ export function visit(node, options = {}) {
             const delay = ts.isNumericLiteral(delayNode) ? delayNode.text : visit(delayNode);
             return `time.AfterFunc(${delay} * time.Millisecond, ${callback.trimEnd()})`;
         }
+        const arrayHigherOrderCall = visitArrayHigherOrderCall(node);
+        if (arrayHigherOrderCall) {
+            return arrayHigherOrderCall;
+        }
         const caller = visit(node.expression);
         const safeCaller = getSafeName(caller);
         const typeArgs = getTypeArguments(node.typeArguments);
@@ -128,7 +204,13 @@ export function visit(node, options = {}) {
     else if (ts.isPostfixUnaryExpression(node)) {
         return `${visit(node.operand, { inline: true })}${getOperatorText(node.operator)}`;
     }
+    else if (ts.isConditionalExpression(node)) {
+        return visitConditionalExpression(node);
+    }
     else if (ts.isBinaryExpression(node)) {
+        if (node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+            return visitNullishCoalescingExpression(node);
+        }
         let op = node.operatorToken.getText();
         if (op === '===')
             op = '==';
@@ -217,28 +299,56 @@ export function visit(node, options = {}) {
         const name = visit(node.name, { inline: true });
         const safeName = getSafeName(name);
         const typeParams = getTypeParameters(node.typeParameters);
-        const parameters = node.parameters
-            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
-            .join(', ');
+        const parameterInfo = getFunctionParametersInfo(node.parameters);
         const returnType = node.type ? ` ${getType(node.type)}` : '';
         if (options.isOutside) {
-            return `func ${safeName}${typeParams}(${parameters})${returnType} ${visit(node.body)}`;
+            return `func ${safeName}${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
+                prefixBlockContent: parameterInfo.prefixBlockContent
+            })}`;
         }
-        return `${safeName} := func${typeParams}(${parameters})${returnType} ${visit(node.body)}`;
+        return `${safeName} := func${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
+            prefixBlockContent: parameterInfo.prefixBlockContent
+        })}`;
     }
     else if (ts.isArrowFunction(node)) {
-        const parameters = node.parameters
-            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
-            .join(', ');
+        const parameterInfo = getFunctionParametersInfo(node.parameters);
         const returnType = node.type ? ` ${getType(node.type)}` : '';
-        return `func(${parameters})${returnType} ${visit(node.body)}`;
+        if (parameterInfo.prefixBlockContent && !ts.isBlock(node.body)) {
+            return `func(${parameterInfo.signature})${returnType} {\n\t\t${parameterInfo.prefixBlockContent}return ${visit(node.body)};\n\t}`;
+        }
+        return `func(${parameterInfo.signature})${returnType} ${visit(node.body, {
+            prefixBlockContent: parameterInfo.prefixBlockContent
+        })}`;
     }
     else if (node.kind === ts.SyntaxKind.ThisKeyword) {
         return 'self';
     }
+    else if (ts.isEnumDeclaration(node)) {
+        const enumName = node.name.text;
+        enumNames.add(enumName);
+        enumBaseTypes.set(enumName, getEnumBaseType(node));
+        if (options.addFunctionOutside) {
+            outsideNodes.push(node);
+            return '';
+        }
+        return visitEnumDeclaration(node);
+    }
+    else if (ts.isTypeAliasDeclaration(node)) {
+        typeAliases.set(node.name.text, node.type);
+        return '';
+    }
     else if (ts.isInterfaceDeclaration(node)) {
         if (options.addFunctionOutside) {
             outsideNodes.push(node);
+            const properties = new Map();
+            for (const member of node.members) {
+                if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                    properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+                }
+            }
+            if (properties.size > 0) {
+                interfacePropertyTypes.set(visit(node.name), properties);
+            }
             return '';
         }
         const name = visit(node.name);
@@ -254,6 +364,7 @@ export function visit(node, options = {}) {
             }
         }
         const methods = [];
+        const properties = [];
         for (const member of node.members) {
             if (ts.isMethodSignature(member)) {
                 const methodName = visit(member.name);
@@ -263,6 +374,13 @@ export function visit(node, options = {}) {
                 const returnType = member.type ? ` ${getType(member.type)}` : '';
                 methods.push(`\t${methodName}(${params})${returnType}`);
             }
+            else if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                properties.push(`\t${member.name.text} ${getOptionalNodeType(member.type, !!member.questionToken)}`);
+            }
+        }
+        if (properties.length > 0 && methods.length === 0) {
+            const fields = [...extendedInterfaces.map((e) => `\t${e}`), ...properties];
+            return `type ${name}${typeParams} struct {\n${fields.join('\n')}\n}`;
         }
         const members = [...extendedInterfaces.map((e) => `\t${e}`), ...methods];
         return `type ${name}${typeParams} interface {\n${members.join('\n')}\n}`;
@@ -270,7 +388,20 @@ export function visit(node, options = {}) {
     else if (ts.isClassDeclaration(node)) {
         if (options.addFunctionOutside) {
             outsideNodes.push(node);
-            classNames.add(visit(node.name));
+            const className = visit(node.name);
+            classNames.add(className);
+            const properties = new Map();
+            const methods = new Map();
+            for (const member of node.members) {
+                if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
+                    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{}');
+                }
+            }
+            classPropertyTypes.set(className, properties);
+            classMethodReturnTypes.set(className, methods);
             return '';
         }
         const name = visit(node.name);
@@ -296,7 +427,7 @@ export function visit(node, options = {}) {
                     fieldType = `[]${getType(member.type, true)}`;
                 }
                 else {
-                    fieldType = member.type ? getType(member.type) : 'interface{}';
+                    fieldType = getOptionalNodeType(member.type, !!member.questionToken);
                 }
                 fields.push(`\t${fieldName} ${fieldType}`);
             }
@@ -304,7 +435,7 @@ export function visit(node, options = {}) {
         let result = `type ${name}${typeParams} struct {\n${fields.join('\n')}\n}\n\n`;
         const ctor = node.members.find((m) => ts.isConstructorDeclaration(m));
         if (ctor) {
-            const params = ctor.parameters.map((p) => `${visit(p.name)} ${getType(p.type)}`).join(', ');
+            const ctorParameterInfo = getFunctionParametersInfo(ctor.parameters);
             const bodyStatements = ctor.body?.statements
                 .filter((s) => {
                 if (ts.isExpressionStatement(s) && ts.isCallExpression(s.expression)) {
@@ -314,7 +445,7 @@ export function visit(node, options = {}) {
             })
                 .map((s) => visit(s))
                 .join('\t') ?? '';
-            result += `func New${name}${typeParams}(${params}) *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${bodyStatements}return self;\n\t}\n\n`;
+            result += `func New${name}${typeParams}(${ctorParameterInfo.signature}) *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${ctorParameterInfo.prefixBlockContent}${bodyStatements}return self;\n\t}\n\n`;
         }
         else {
             result += `func New${name}${typeParams}() *${name}${typeParamNames} {\n\t\treturn &${name}${typeParamNames}{}\n\t}\n\n`;
@@ -322,11 +453,11 @@ export function visit(node, options = {}) {
         for (const member of node.members) {
             if (ts.isMethodDeclaration(member)) {
                 const methodName = visit(member.name);
-                const params = member.parameters
-                    .map((p) => `${visit(p.name)} ${getType(p.type)}`)
-                    .join(', ');
+                const methodParameterInfo = getFunctionParametersInfo(member.parameters);
                 const returnType = member.type ? ` ${getType(member.type)}` : '';
-                result += `func (self *${name}${typeParamNames}) ${methodName}(${params})${returnType} ${visit(member.body)}\n\n`;
+                result += `func (self *${name}${typeParamNames}) ${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, {
+                    prefixBlockContent: methodParameterInfo.prefixBlockContent
+                })}\n\n`;
             }
         }
         return result.trim();
@@ -336,6 +467,19 @@ export function visit(node, options = {}) {
         if (className === 'Promise') {
             return visitNewPromise(node);
         }
+        if (className === 'RegExp') {
+            importedPackages.add('regexp');
+            const nodeArgs = node.arguments ?? [];
+            if (nodeArgs.length >= 2 && ts.isStringLiteral(nodeArgs[1])) {
+                const pattern = visit(nodeArgs[0]);
+                const flags = jsRegexFlagsToGo(nodeArgs[1].text);
+                return `regexp.MustCompile("${flags}" + ${pattern})`;
+            }
+            if (nodeArgs.length >= 1) {
+                return `regexp.MustCompile(${visit(nodeArgs[0])})`;
+            }
+            return `regexp.MustCompile("")`;
+        }
         const typeArgs = getTypeArguments(node.typeArguments);
         const args = node.arguments ? node.arguments.map((a) => visit(a)) : [];
         return `New${className}${typeArgs}(${args.join(', ')})`;
@@ -379,9 +523,492 @@ function getTypeText(typeNode) {
     }
     return getType(typeNode);
 }
+function toGoStringLiteral(value) {
+    return JSON.stringify(value);
+}
+function visitTemplateExpression(node) {
+    const parts = [];
+    if (node.head.text.length > 0) {
+        parts.push(toGoStringLiteral(node.head.text));
+    }
+    for (const span of node.templateSpans) {
+        importedPackages.add('fmt');
+        parts.push(`fmt.Sprintf("%v", ${visit(span.expression)})`);
+        if (span.literal.text.length > 0) {
+            parts.push(toGoStringLiteral(span.literal.text));
+        }
+    }
+    if (parts.length === 0) {
+        return '""';
+    }
+    return parts.join(' + ');
+}
+function hasQuestionDot(node) {
+    return ('questionDotToken' in node &&
+        !!node.questionDotToken);
+}
+function getTempName(prefix) {
+    return `__${prefix}_${goSafeId()}__`;
+}
+function inferExpectedTypeFromContext(node) {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && parent.initializer === node && parent.type) {
+        return getType(parent.type);
+    }
+    if (ts.isReturnStatement(parent)) {
+        let scope = parent.parent;
+        while (scope) {
+            if (ts.isFunctionDeclaration(scope) ||
+                ts.isMethodDeclaration(scope) ||
+                ts.isFunctionExpression(scope) ||
+                ts.isArrowFunction(scope)) {
+                if (scope.type)
+                    return getType(scope.type);
+                break;
+            }
+            scope = scope.parent;
+        }
+    }
+    return undefined;
+}
+function inferExpressionType(expr) {
+    if (ts.isParenthesizedExpression(expr))
+        return inferExpressionType(expr.expression);
+    if (ts.isNonNullExpression(expr))
+        return inferExpressionType(expr.expression);
+    if (ts.isAsExpression(expr))
+        return getType(expr.type);
+    if (ts.isTypeAssertionExpression(expr))
+        return getType(expr.type);
+    if (ts.isStringLiteral(expr) ||
+        ts.isNoSubstitutionTemplateLiteral(expr) ||
+        ts.isTemplateExpression(expr)) {
+        return 'string';
+    }
+    if (ts.isNumericLiteral(expr))
+        return 'float64';
+    if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword)
+        return 'bool';
+    if (expr.kind === ts.SyntaxKind.NullKeyword)
+        return 'nil';
+    if (ts.isIdentifier(expr))
+        return variableGoTypes.get(expr.text);
+    if (ts.isArrayLiteralExpression(expr)) {
+        if (expr.elements.length === 0)
+            return '[]interface{}';
+        const firstElementType = inferExpressionType(expr.elements[0]) ?? 'interface{}';
+        return `[]${firstElementType}`;
+    }
+    if (ts.isPropertyAccessExpression(expr)) {
+        if (ts.isIdentifier(expr.expression) && enumNames.has(expr.expression.text)) {
+            const enumType = getSafeName(expr.expression.text);
+            return enumType;
+        }
+        const leftType = inferExpressionType(expr.expression);
+        if (expr.name.text === 'length')
+            return 'float64';
+        const resolvedLeftType = leftType?.replace(/^\*/, '').replace(/\[.*\]$/, '');
+        const resolvedPropertyType = resolvedLeftType
+            ? (classPropertyTypes.get(resolvedLeftType)?.get(expr.name.text) ??
+                interfacePropertyTypes.get(resolvedLeftType)?.get(expr.name.text))
+            : undefined;
+        if (hasQuestionDot(expr)) {
+            if (leftType && leftType.startsWith('*')) {
+                const memberType = resolvedPropertyType ?? 'interface{}';
+                return makeNullableType(memberType);
+            }
+            return 'interface{}';
+        }
+        if (resolvedPropertyType) {
+            return resolvedPropertyType;
+        }
+        if (ts.isIdentifier(expr.expression)) {
+            const className = variableClassNames.get(expr.expression.text);
+            const memberType = className
+                ? classPropertyTypes.get(className)?.get(expr.name.text)
+                : undefined;
+            if (memberType)
+                return memberType;
+        }
+    }
+    if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) {
+        const methodName = expr.expression.name.text;
+        const ownerType = inferExpressionType(expr.expression.expression);
+        if (isArrayLikeGoType(ownerType)) {
+            const elementType = getArrayElementTypeFromGoType(ownerType);
+            if (methodName === 'map') {
+                const callback = expr.arguments[0];
+                const mappedType = callback
+                    ? inferArrayCallbackReturnType(callback, elementType, elementType)
+                    : elementType;
+                return `[]${mappedType}`;
+            }
+            if (methodName === 'filter')
+                return `[]${elementType}`;
+            if (methodName === 'some')
+                return 'bool';
+            if (methodName === 'find')
+                return elementType;
+            if (methodName === 'join')
+                return 'string';
+        }
+        if (ownerType && ownerType.startsWith('*')) {
+            const className = ownerType.replace(/^\*/, '').replace(/\[.*\]$/, '');
+            const returnType = classMethodReturnTypes.get(className)?.get(methodName);
+            if (returnType) {
+                if (hasQuestionDot(expr) || hasQuestionDot(expr.expression)) {
+                    return makeNullableType(returnType);
+                }
+                return returnType;
+            }
+        }
+        if (ts.isIdentifier(expr.expression.expression)) {
+            const className = variableClassNames.get(expr.expression.expression.text);
+            const returnType = className
+                ? classMethodReturnTypes.get(className)?.get(methodName)
+                : undefined;
+            if (returnType) {
+                if (hasQuestionDot(expr) || hasQuestionDot(expr.expression)) {
+                    return makeNullableType(returnType);
+                }
+                return returnType;
+            }
+        }
+    }
+    if (ts.isConditionalExpression(expr)) {
+        const whenTrueType = inferExpressionType(expr.whenTrue);
+        const whenFalseType = inferExpressionType(expr.whenFalse);
+        if (whenTrueType && whenTrueType === whenFalseType)
+            return whenTrueType;
+        return whenTrueType ?? whenFalseType;
+    }
+    if (ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+        const leftType = inferExpressionType(expr.left);
+        const rightType = inferExpressionType(expr.right);
+        if (leftType && leftType.startsWith('*') && rightType === leftType.slice(1)) {
+            return rightType;
+        }
+        return rightType ?? leftType;
+    }
+    return undefined;
+}
+function makeNullableType(typeName) {
+    if (!typeName || typeName === 'interface{}' || typeName.startsWith('*'))
+        return typeName || 'interface{}';
+    if (['string', 'float64', 'bool'].includes(typeName))
+        return `*${typeName}`;
+    return typeName;
+}
+function visitConditionalExpression(node) {
+    const whenTrue = visit(node.whenTrue);
+    const whenFalse = visit(node.whenFalse);
+    const resultType = inferExpectedTypeFromContext(node) ||
+        (() => {
+            const whenTrueType = inferExpressionType(node.whenTrue);
+            const whenFalseType = inferExpressionType(node.whenFalse);
+            if (whenTrueType && whenTrueType === whenFalseType)
+                return whenTrueType;
+            return whenTrueType ?? whenFalseType ?? 'interface{}';
+        })();
+    return `func() ${resultType} { if ${visit(node.condition)} { return ${whenTrue} }; return ${whenFalse} }()`;
+}
+function visitNullishCoalescingExpression(node) {
+    const leftType = inferExpressionType(node.left);
+    const rightType = inferExpressionType(node.right);
+    if (leftType && leftType.startsWith('*')) {
+        const leftValueType = leftType.slice(1);
+        const expectedType = inferExpectedTypeFromContext(node);
+        const resultType = expectedType || (rightType === leftValueType ? leftValueType : (rightType ?? leftType));
+        const tmp = getTempName('nullish');
+        const leftExpr = visit(node.left);
+        const rightExpr = visit(node.right);
+        const returnLeft = resultType === leftValueType ? `*${tmp}` : tmp;
+        return `func() ${resultType} { ${tmp} := ${leftExpr}; if ${tmp} == nil { return ${rightExpr} }; return ${returnLeft} }()`;
+    }
+    return visit(node.left);
+}
+function visitOptionalPropertyAccess(node) {
+    const baseExpr = visit(node.expression);
+    const baseType = inferExpressionType(node.expression);
+    if (!baseType || !baseType.startsWith('*')) {
+        const objectType = resolveExpressionType(node.expression);
+        return getAcessString(baseExpr, visit(node.name), objectType);
+    }
+    const className = baseType.replace(/^\*/, '').replace(/\[.*\]$/, '');
+    const propertyType = classPropertyTypes.get(className)?.get(node.name.text) ?? 'interface{}';
+    const nullableType = makeNullableType(propertyType);
+    const tmp = getTempName('opt');
+    const propertyAccess = `${tmp}.${visit(node.name)}`;
+    if (nullableType.startsWith('*') && nullableType.slice(1) === propertyType) {
+        const valueTemp = getTempName('optv');
+        return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; ${valueTemp} := ${propertyAccess}; return &${valueTemp} }()`;
+    }
+    return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; return ${propertyAccess} }()`;
+}
+function visitOptionalElementAccess(node) {
+    const baseExpr = visit(node.expression);
+    const baseType = inferExpressionType(node.expression);
+    if (!baseType || !baseType.startsWith('*')) {
+        return `${baseExpr}[int(${visit(node.argumentExpression)})]`;
+    }
+    const valueType = inferExpectedTypeFromContext(node) ?? 'interface{}';
+    const nullableType = makeNullableType(valueType);
+    const tmp = getTempName('opte');
+    const elementExpr = `${tmp}[int(${visit(node.argumentExpression)})]`;
+    if (nullableType.startsWith('*') && nullableType.slice(1) === valueType) {
+        const valueTemp = getTempName('optev');
+        return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; ${valueTemp} := ${elementExpr}; return &${valueTemp} }()`;
+    }
+    return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; return ${elementExpr} }()`;
+}
+function visitOptionalCall(node) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return `${visit(node.expression)}(${node.arguments.map((a) => visit(a)).join(', ')})`;
+    }
+    const baseNode = node.expression.expression;
+    const methodName = node.expression.name.text;
+    const baseExpr = visit(baseNode);
+    const baseType = inferExpressionType(baseNode);
+    const args = node.arguments.map((a) => visit(a)).join(', ');
+    if (!baseType || !baseType.startsWith('*')) {
+        return `${baseExpr}.${methodName}(${args})`;
+    }
+    const className = baseType.replace(/^\*/, '').replace(/\[.*\]$/, '');
+    const returnType = classMethodReturnTypes.get(className)?.get(methodName) ?? 'interface{}';
+    const nullableType = makeNullableType(returnType);
+    const tmp = getTempName('optc');
+    const callExpr = `${tmp}.${methodName}(${args})`;
+    if (nullableType.startsWith('*') && nullableType.slice(1) === returnType) {
+        const valueTemp = getTempName('optcv');
+        return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; ${valueTemp} := ${callExpr}; return &${valueTemp} }()`;
+    }
+    return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; return ${callExpr} }()`;
+}
+function isArrayLikeGoType(goType) {
+    return !!goType && goType.startsWith('[]');
+}
+function getArrayElementTypeFromGoType(goType) {
+    if (!goType.startsWith('[]'))
+        return 'interface{}';
+    const elementType = goType.slice(2);
+    return elementType || 'interface{}';
+}
+function inferArrayCallbackReturnType(callback, elementType, fallbackType) {
+    if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+        if (callback.type) {
+            const explicitType = getType(callback.type);
+            return explicitType || fallbackType;
+        }
+        if (ts.isBlock(callback.body)) {
+            return fallbackType;
+        }
+        const inferred = inferExpressionType(callback.body);
+        return inferred ?? fallbackType;
+    }
+    if (ts.isIdentifier(callback)) {
+        const knownType = variableGoTypes.get(callback.text);
+        if (knownType)
+            return knownType;
+    }
+    return fallbackType;
+}
+function buildArrayCallbackInfo(callback, elementType, forcedReturnType) {
+    if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+        const paramCount = callback.parameters.length;
+        const callbackReturnType = forcedReturnType ?? inferArrayCallbackReturnType(callback, elementType, 'interface{}');
+        const params = [];
+        if (paramCount > 0) {
+            params.push(`${visit(callback.parameters[0].name)} ${elementType}`);
+        }
+        if (paramCount > 1) {
+            params.push(`${visit(callback.parameters[1].name)} float64`);
+        }
+        if (paramCount > 2) {
+            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}`;
+        return {
+            fnExpr: `func(${params.join(', ')}) ${callbackReturnType} ${body}`,
+            paramCount,
+            returnType: callbackReturnType
+        };
+    }
+    return {
+        fnExpr: visit(callback),
+        paramCount: 1,
+        returnType: forcedReturnType ?? 'interface{}'
+    };
+}
+function buildArrayCallbackInvocation(callbackInfo, itemVar, indexVar, arrayVar) {
+    const args = [];
+    if (callbackInfo.paramCount > 0)
+        args.push(itemVar);
+    if (callbackInfo.paramCount > 1)
+        args.push(`float64(${indexVar})`);
+    if (callbackInfo.paramCount > 2)
+        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)) {
+        return undefined;
+    }
+    const arrayExprNode = node.expression.expression;
+    const arrayExpr = visit(arrayExprNode);
+    const ownerType = inferExpressionType(arrayExprNode);
+    const elementType = isArrayLikeGoType(ownerType)
+        ? getArrayElementTypeFromGoType(ownerType)
+        : 'interface{}';
+    if (methodName === 'join') {
+        importedPackages.add('strings');
+        importedPackages.add('fmt');
+        const separator = node.arguments[0] ? visit(node.arguments[0]) : '""';
+        const arrVar = getTempName('arrjoin');
+        const partsVar = getTempName('parts');
+        return `func() string { ${arrVar} := ${arrayExpr}; ${partsVar} := make([]string, len(${arrVar})); for i, v := range ${arrVar} { ${partsVar}[i] = fmt.Sprintf("%v", v) }; return strings.Join(${partsVar}, ${separator}) }()`;
+    }
+    const callback = node.arguments[0];
+    if (!callback) {
+        return undefined;
+    }
+    const arrVar = getTempName('arrhof');
+    const idxVar = getTempName('i');
+    const itemVar = getTempName('item');
+    if (methodName === 'map') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, elementType);
+        const mappedType = callbackInfo.returnType || 'interface{}';
+        const resultVar = getTempName('mapres');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() []${mappedType} { ${arrVar} := ${arrayExpr}; ${resultVar} := make([]${mappedType}, 0, len(${arrVar})); for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { ${resultVar} = append(${resultVar}, ${callbackCall}) }; return ${resultVar} }()`;
+    }
+    if (methodName === 'filter') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+        const resultVar = getTempName('filterres');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() []${elementType} { ${arrVar} := ${arrayExpr}; ${resultVar} := make([]${elementType}, 0, len(${arrVar})); for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { ${resultVar} = append(${resultVar}, ${itemVar}) } }; return ${resultVar} }()`;
+    }
+    if (methodName === 'some') {
+        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 true } }; return false }()`;
+    }
+    const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+    const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+    const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+    return `func() ${elementType} { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { return ${itemVar} } }; var __zero ${elementType}; return __zero }()`;
+}
+function getAliasType(name, seen = new Set()) {
+    const aliasType = typeAliases.get(name);
+    if (!aliasType)
+        return undefined;
+    if (seen.has(name))
+        return undefined;
+    if (ts.isTypeReferenceNode(aliasType) && ts.isIdentifier(aliasType.typeName)) {
+        const nestedName = aliasType.typeName.text;
+        if (typeAliases.has(nestedName)) {
+            seen.add(name);
+            return getAliasType(nestedName, seen) ?? aliasType;
+        }
+    }
+    return aliasType;
+}
+function getOptionalNodeType(typeNode, isOptional) {
+    const baseType = typeNode ? getType(typeNode) : 'interface{}';
+    if (!isOptional)
+        return baseType;
+    if (baseType === 'interface{}' || baseType.startsWith('*'))
+        return baseType;
+    if (['string', 'float64', 'bool'].includes(baseType))
+        return `*${baseType}`;
+    return baseType;
+}
+function getEnumMemberName(name) {
+    if (ts.isIdentifier(name)) {
+        return getSafeName(name.text);
+    }
+    if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        const sanitized = name.text.replace(/[^a-zA-Z0-9_]/g, '_');
+        return sanitized.length > 0 ? sanitized : 'Member';
+    }
+    return 'Member';
+}
+function getEnumBaseType(node) {
+    for (const member of node.members) {
+        const initializer = member.initializer;
+        if (!initializer)
+            continue;
+        if (ts.isStringLiteral(initializer) || ts.isNoSubstitutionTemplateLiteral(initializer)) {
+            return 'string';
+        }
+    }
+    return 'float64';
+}
+function readNumericEnumInitializer(initializer) {
+    if (ts.isNumericLiteral(initializer)) {
+        return Number(initializer.text);
+    }
+    if (ts.isPrefixUnaryExpression(initializer) &&
+        initializer.operator === ts.SyntaxKind.MinusToken &&
+        ts.isNumericLiteral(initializer.operand)) {
+        return -Number(initializer.operand.text);
+    }
+    return undefined;
+}
+function visitEnumDeclaration(node) {
+    const enumName = getSafeName(node.name.text);
+    const baseType = enumBaseTypes.get(node.name.text) ?? getEnumBaseType(node);
+    let nextNumericValue = 0;
+    let canAutoIncrement = true;
+    const members = [];
+    for (const member of node.members) {
+        const memberName = getEnumMemberName(member.name);
+        const symbolName = `${enumName}_${memberName}`;
+        let valueExpr;
+        if (member.initializer) {
+            if (baseType === 'float64') {
+                const numericValue = readNumericEnumInitializer(member.initializer);
+                if (numericValue !== undefined) {
+                    valueExpr = `${numericValue}`;
+                    nextNumericValue = numericValue + 1;
+                    canAutoIncrement = true;
+                }
+                else {
+                    valueExpr = `float64(${visit(member.initializer)})`;
+                    canAutoIncrement = false;
+                }
+            }
+            else {
+                valueExpr = visit(member.initializer);
+            }
+        }
+        else if (baseType === 'float64') {
+            const currentValue = canAutoIncrement ? nextNumericValue : 0;
+            valueExpr = `${currentValue}`;
+            nextNumericValue = currentValue + 1;
+        }
+        else {
+            valueExpr = toGoStringLiteral(memberName);
+        }
+        members.push(`\t${symbolName} ${enumName} = ${enumName}(${valueExpr})`);
+    }
+    return `type ${enumName} ${baseType}\n\nvar (\n${members.join('\n')}\n)`;
+}
 function getType(typeNode, getArrayType = false) {
     if (!typeNode)
         return ':';
+    if (ts.isArrayTypeNode(typeNode)) {
+        const elementType = getType(typeNode.elementType);
+        return getArrayType ? elementType : `[]${elementType}`;
+    }
     // Handle union types (e.g. string | null, number | undefined)
     if (ts.isUnionTypeNode(typeNode)) {
         const nonNullTypes = typeNode.types.filter((t) => t.kind !== ts.SyntaxKind.NullKeyword &&
@@ -401,9 +1028,19 @@ function getType(typeNode, getArrayType = false) {
     }
     if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
+        if (enumNames.has(name)) {
+            return getSafeName(name);
+        }
+        const aliasType = getAliasType(name);
+        if (aliasType) {
+            return getType(aliasType, getArrayType);
+        }
         if (name === 'Promise' && typeNode.typeArguments && typeNode.typeArguments.length > 0) {
             return `chan ${getType(typeNode.typeArguments[0])}`;
         }
+        if (name === 'RegExp') {
+            return '*regexp.Regexp';
+        }
         const typeArgs = getTypeArguments(typeNode.typeArguments);
         if (classNames.has(name)) {
             return `*${name}${typeArgs}`;
@@ -460,6 +1097,20 @@ function getTypeCategory(typeNode) {
     }
     return undefined;
 }
+function getClassNameFromTypeNode(typeNode) {
+    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+        return classNames.has(typeNode.typeName.text) ? typeNode.typeName.text : undefined;
+    }
+    if (ts.isUnionTypeNode(typeNode)) {
+        const nonNullTypes = typeNode.types.filter((t) => t.kind !== ts.SyntaxKind.NullKeyword &&
+            t.kind !== ts.SyntaxKind.UndefinedKeyword &&
+            !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));
+        if (nonNullTypes.length === 1) {
+            return getClassNameFromTypeNode(nonNullTypes[0]);
+        }
+    }
+    return undefined;
+}
 function resolveExpressionType(expr) {
     if (ts.isIdentifier(expr)) {
         return variableTypes.get(expr.text);
@@ -615,6 +1266,10 @@ const stringMethodHandlers = {
         return `fmt.Sprintf("%v", ${obj})`;
     }
 };
+const regexpMethodHandlers = {
+    test: (obj, args) => `${obj}.MatchString(${args[0]})`,
+    exec: (obj, args) => `${obj}.FindStringSubmatch(${args[0]})`
+};
 const arrayMethodHandlers = {
     push: (obj, args) => `${obj} = append(${obj}, ${args.join(', ')})`,
     join: (obj, args) => {
@@ -638,6 +1293,14 @@ function getDynamicCallHandler(caller, objectType) {
     const dotIndex = caller.lastIndexOf('.');
     if (dotIndex !== -1) {
         const methodName = caller.substring(dotIndex + 1);
+        // toString() is universal — works for any type including numbers and objects
+        if (methodName === 'toString') {
+            return (c) => {
+                const obj = c.substring(0, dotIndex);
+                importedPackages.add('fmt');
+                return `fmt.Sprintf("%v", ${obj})`;
+            };
+        }
         // Class instances use their own methods — never intercept
         if (objectType === 'class')
             return null;
@@ -648,9 +1311,15 @@ function getDynamicCallHandler(caller, objectType) {
         else if (objectType === 'array') {
             handler = arrayMethodHandlers[methodName];
         }
+        else if (objectType === 'RegExp') {
+            handler = regexpMethodHandlers[methodName];
+        }
         else {
             // Unknown type: try both maps for backward compatibility
-            handler = stringMethodHandlers[methodName] ?? arrayMethodHandlers[methodName];
+            handler =
+                stringMethodHandlers[methodName] ??
+                    arrayMethodHandlers[methodName] ??
+                    regexpMethodHandlers[methodName];
         }
         if (handler) {
             return (c, args) => {
@@ -690,6 +1359,16 @@ function getOperatorText(operator) {
 function getTimerName(name) {
     return `__timer_${name.replaceAll(' ', '_').replaceAll('"', '')}__`;
 }
+function jsRegexFlagsToGo(flags) {
+    let goFlags = '';
+    if (flags.includes('i'))
+        goFlags += 'i';
+    if (flags.includes('m'))
+        goFlags += 'm';
+    if (flags.includes('s'))
+        goFlags += 's';
+    return goFlags ? `(?${goFlags})` : '';
+}
 function getTypeParameters(typeParameters) {
     if (!typeParameters || typeParameters.length === 0)
         return '';
@@ -712,6 +1391,59 @@ function getTypeArguments(typeArguments) {
     const args = typeArguments.map((ta) => getType(ta));
     return `[${args.join(', ')}]`;
 }
+function getParameterGoType(param) {
+    if (param.type) {
+        const explicitType = getType(param.type);
+        return explicitType === ':' ? 'interface{}' : explicitType;
+    }
+    if (param.initializer) {
+        const inferredType = inferExpressionType(param.initializer);
+        if (inferredType && inferredType !== 'nil' && inferredType !== ':') {
+            return inferredType;
+        }
+    }
+    return 'interface{}';
+}
+function getFunctionParametersInfo(parameters) {
+    if (parameters.length === 0) {
+        return { signature: '', prefixBlockContent: '' };
+    }
+    const firstDefaultIndex = parameters.findIndex((p) => !!p.initializer);
+    if (firstDefaultIndex === -1) {
+        return {
+            signature: parameters.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`).join(', '),
+            prefixBlockContent: ''
+        };
+    }
+    const hasRequiredAfterDefault = parameters
+        .slice(firstDefaultIndex)
+        .some((p) => !p.initializer);
+    if (hasRequiredAfterDefault) {
+        return {
+            signature: parameters.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`).join(', '),
+            prefixBlockContent: ''
+        };
+    }
+    const requiredParams = parameters.slice(0, firstDefaultIndex);
+    const defaultedParams = parameters.slice(firstDefaultIndex);
+    const signatureParts = requiredParams.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`);
+    signatureParts.push('__defaultArgs ...interface{}');
+    const prefixBlockContent = defaultedParams
+        .map((param, index) => {
+        const paramName = visit(param.name);
+        const paramType = getParameterGoType(param);
+        const defaultValue = visit(param.initializer);
+        if (paramType === 'interface{}') {
+            return `var ${paramName} interface{}\n\t\tif len(__defaultArgs) > ${index} {\n\t\t\t${paramName} = __defaultArgs[${index}]\n\t\t} else {\n\t\t\t${paramName} = ${defaultValue}\n\t\t}\n\t\t`;
+        }
+        return `var ${paramName} ${paramType}\n\t\tif len(__defaultArgs) > ${index} {\n\t\t\t${paramName} = __defaultArgs[${index}].(${paramType})\n\t\t} else {\n\t\t\t${paramName} = ${defaultValue}\n\t\t}\n\t\t`;
+    })
+        .join('');
+    return {
+        signature: signatureParts.join(', '),
+        prefixBlockContent
+    };
+}
 function getSafeName(name) {
     if (!dangerousNames.has(name)) {
         return name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typenative",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Build native applications using Typescript.",
   "type": "module",
   "bin": {
@@ -25,7 +25,13 @@
     "test11": "node ./bin/index --source test/test11.spec.ts --script",
     "test12": "node ./bin/index --source test/test12.spec.ts --script",
     "test13": "node ./bin/index --source test/test13.spec.ts --script",
-    "test14": "node ./bin/index --source test/test14.spec.ts --script"
+    "test14": "node ./bin/index --source test/test14.spec.ts --script",
+    "test15": "node ./bin/index --source test/test15.spec.ts --script",
+    "test16": "node ./bin/index --source test/test16.spec.ts --script",
+    "test17": "node ./bin/index --source test/test17.spec.ts --script",
+    "test18": "node ./bin/index --source test/test18.spec.ts --script",
+    "test19": "node ./bin/index --source test/test19.spec.ts --script",
+    "test20": "node ./bin/index --source test/Test20.spec.ts --script"
   },
   "repository": {
     "type": "git",

package/types/typenative.d.ts

@@ -3,15 +3,16 @@ interface Boolean {}
 interface CallableFunction extends Function {}
 
 interface Function {
-  apply(thisArg: any, argArray?: any): any;
+  /*   apply(thisArg: any, argArray?: any): any;
   call(thisArg: any, ...argArray: any[]): any;
-  bind(thisArg: any, ...argArray: any[]): any;
+  bind(thisArg: any, ...argArray: any[]): any; */
 }
 
 interface IArguments {
   [index: number]: any;
   length: number;
 }
+
 interface NewableFunction extends Function {}
 
 interface Number {
@@ -28,6 +29,12 @@ interface RegExp {
   exec(string: string): string[] | null;
 }
 
+interface RegExpConstructor {
+  new (pattern: string, flags?: string): RegExp;
+}
+
+declare var RegExp: RegExpConstructor;
+
 interface SymbolConstructor {
   readonly iterator: unique symbol;
 }
@@ -74,6 +81,22 @@ interface Array<T> extends IterableIterator<T> {
    * Returns a copy of a section of an array.
    */
   slice(start?: number, end?: number): T[];
+  /**
+   * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+   */
+  map<U>(callback: (value: T, index?: number, array?: T[]) => U): U[];
+  /**
+   * Returns the elements of an array that meet the condition specified in a callback function.
+   */
+  filter(callback: (value: T, index?: number, array?: T[]) => boolean): T[];
+  /**
+   * Determines whether the specified callback function returns true for any element of an array.
+   */
+  some(callback: (value: T, index?: number, array?: T[]) => boolean): boolean;
+  /**
+   * Returns the value of the first element in the array where callback is true, and undefined otherwise.
+   */
+  find(callback: (value: T, index?: number, array?: T[]) => boolean): T | undefined;
   /**
    * Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
    */