typenative 0.0.19 → 0.0.20

package/CHANGELOG.md

@@ -5,6 +5,33 @@ 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.20] - 2026-03-16
+
+### Added
+
+- **Spread in array literals**: `[...arr1, ...arr2]` → `append(append([]T{}, arr1...), arr2...)`
+- **Rest parameters**: `function(...args: T[])` → Go variadic `func(...args T)`
+- **Spread in function calls**: `fn(...args)` → `fn(args...)`
+- **Array destructuring**: `const [a, b] = arr` → Go index assignments
+- **Object shorthand**: `{ name }` → `{ name: name }` in struct literals
+- **Static class members**: `static method()` / `static prop` → `ClassName_method()` / `ClassName_prop` package-level declarations; `ClassName.method()` calls correctly resolve
+- **Getters/Setters**: `get prop()` → `Get_prop()` method, `set prop(v)` → `Set_prop(v)` method
+- **`for...in` loops**: `for (const k in obj)` → `for k := range obj`
+- **`Object.entries()` in `for...of`**: `for (const [k, v] of Object.entries(map))` unwraps to `for k, v := range map`
+- **Named function expression IIFEs**: `(function name() { ... })()` → anonymous `func() { ... }()`
+- **`process` global**: `process.argv` → `os.Args`, `process.platform` → `runtime.GOOS`, `process.exit()` → `os.Exit()`, `process.cwd()` → `os.Getwd()`
+- **`JSON.stringify()` / `JSON.parse()`**: mapped to `encoding/json` `Marshal`/`Unmarshal`
+- **`Object.keys()` / `Object.values()` / `Object.entries()`**: map iteration helpers
+- **Array methods**: `findIndex`, `every`, `forEach`, `reduce`, `pop`, `shift`, `unshift`, `reverse`, `sort`, `concat`, `flat`, `at`
+- **String methods**: `padStart`, `padEnd`, `match`, `matchAll`, `search`, `at`
+- **Math methods**: `log`, `log2`, `log10`, `sin`, `cos`, `tan`, `trunc`, `sign`
+- **`console.error()`**: maps to `fmt.Fprintln(os.Stderr, ...)`
+- **`String()` / `Number()` / `Boolean()`** conversion functions
+- **Go reserved words protection**: `getSafeName()` now covers all Go keywords (`break`, `case`, `chan`, `continue`, `default`, `defer`, `else`, `fallthrough`, `for`, `func`, `go`, `goto`, `if`, `import`, `interface`, `map`, `package`, `range`, `return`, `select`, `struct`, `switch`, `type`, `var`)
+- **Default import namespaces from npm/local packages**: `import ts from 'typescript'` registers `ts` as a stripped namespace so `ts.method()` → `method()`
+- **Better unsupported syntax warnings**: `console.warn` with syntax kind name and source snippet instead of `console.log`
+- **Type definitions (`typenative.d.ts`)**: added `findIndex`, `every`, `forEach`, `reduce`, `pop`, `shift`, `unshift`, `reverse`, `sort`, `flat`, `concat`, `at` to `Array`; `padStart`, `padEnd`, `match`, `matchAll`, `search`, `at` to `String`; added `JSON`, `Object`, `Process`, extended `Math` and `Console`
+
 ## [0.0.19] - 2026-03-07
 
 ### Added

package/README.md

@@ -29,10 +29,13 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 
 **Variables & Objects**
 
-| Feature               | Supported | Notes                            |
-| --------------------- | :-------: | -------------------------------- |
-| Variable declarations |    ✅     | `let` and `const`                |
-| Object literals       |    ✅     | Transpiled to Go struct literals |
+| Feature                | Supported | Notes                                           |
+| ---------------------- | :-------: | ----------------------------------------------- |
+| Variable declarations  |    ✅     | `let` and `const`                               |
+| Object literals        |    ✅     | Transpiled to Go struct literals                |
+| Object shorthand       |    ✅     | `{ name }` → `{ name: name }`                  |
+| Array destructuring    |    ✅     | `const [a, b] = arr`                            |
+| Object destructuring   |    ✅     | `const { x, y } = obj`                          |
 
 **Operators**
 
@@ -42,6 +45,7 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Comparison operators     |    ✅     | `==`, `!=`, `===`, `!==`, etc. |
 | Logical operators        |    ✅     | `&&`, `\|\|`                   |
 | Increment/Decrement      |    ✅     | `++`, `--`                     |
+| Spread operator          |    ✅     | `[...arr]`, `fn(...args)`      |
 | Non-null assertion (`!`) |    ✅     | Stripped during transpilation  |
 | Ternary expressions      |    ✅     | `condition ? a : b`            |
 | Nullish coalescing       |    ✅     | `??` operator                  |
@@ -54,21 +58,22 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | If/Else statements |    ✅     | Fully supported                                        |
 | Switch statements  |    ✅     | Case and default statements                            |
 | For loops          |    ✅     | Standard `for` loops                                   |
-| For...of loops     |    ✅     | Iteration over arrays                                  |
+| For...of loops     |    ✅     | Arrays, Maps, Sets; `Object.entries()` unwrapping      |
+| For...in loops     |    ✅     | Iterates keys via Go `range`                           |
 | While loops        |    ✅     | Transpiled to Go's `for` loops                         |
 | Do...while loops   |    ✅     | Implemented with conditional break                     |
 | Try/Catch/Finally  |    ✅     | `throw` → `panic`; catch/finally via `defer`/`recover` |
 
 **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(...)`                           |
-| Map                        |    ✅     | `Map<K, V>` → Go `map[K]V`; `.set()`, `.get()`, `.has()`, `.delete()`, `.clear()`, `.size` |
-| Set                        |    ✅     | `Set<T>` → Go `map[T]struct{}`; `.add()`, `.has()`, `.delete()`, `.clear()`, `.size`       |
+| Feature                    | Supported | Notes                                                                                         |
+| -------------------------- | :-------: | --------------------------------------------------------------------------------------------- |
+| Arrays                     |    ✅     | Basic array operations                                                                        |
+| Array methods              |    ✅     | `push`, `pop`, `shift`, `unshift`, `join`, `slice`, `concat`, `reverse`, `sort`, `flat`, `at` |
+| Higher-order array methods |    ✅     | `.map()`, `.filter()`, `.some()`, `.find()`, `.findIndex()`, `.every()`, `.forEach()`, `.reduce()` |
+| Method chaining            |    ✅     | e.g. `.map(...).filter(...).join(...)`                                                        |
+| Map                        |    ✅     | `Map<K, V>` → Go `map[K]V`; `.set()`, `.get()`, `.has()`, `.delete()`, `.clear()`, `.size`  |
+| Set                        |    ✅     | `Set<T>` → Go `map[T]struct{}`; `.add()`, `.has()`, `.delete()`, `.clear()`, `.size`         |
 
 **Functions**
 
@@ -76,10 +81,12 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | ---------------------------- | :-------: | ----------------------------------------------------------- |
 | Function declarations        |    ✅     | Transpiled to Go functions                                  |
 | Arrow functions              |    ✅     | Transpiled to anonymous functions                           |
+| IIFEs                        |    ✅     | `(() => { ... })()` and `(function name() { ... })()`       |
 | Closures over mutable state  |    ✅     | Functions capturing and mutating outer variables            |
 | Function types               |    ✅     | `() => number`, `(x: number) => string` as type annotations |
 | Generics (functions/classes) |    ✅     | Type parameters via Go generics                             |
 | Default parameter values     |    ✅     | `function(x = defaultValue)`                                |
+| Rest parameters              |    ✅     | `function(...args: T[])` → Go variadic                      |
 
 **Classes & Interfaces**
 
@@ -87,6 +94,8 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | ------------------- | :-------: | -------------------------------------------------------------- |
 | Classes             |    ✅     | Transpiled to Go structs with constructor and receiver methods |
 | Class inheritance   |    ✅     | `extends` via embedded structs, `super()` supported            |
+| Static members      |    ✅     | `static method()` / `static prop` → package-level declarations |
+| Getters / Setters   |    ✅     | `get prop()` → `Get_prop()`, `set prop(v)` → `Set_prop(v)`    |
 | Interfaces          |    ✅     | Transpiled to Go interfaces, supports `extends`                |
 | Optional properties |    ✅     | `prop?: Type` in interfaces/types                              |
 | Enums               |    ✅     | `enum` declarations and member access                          |
@@ -104,9 +113,16 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Feature               | Supported | Notes                                                 |
 | --------------------- | :-------: | ----------------------------------------------------- |
 | console.log           |    ✅     | Mapped to `fmt.Println`                               |
+| console.error         |    ✅     | Mapped to `fmt.Fprintln(os.Stderr, ...)`              |
 | console.time/timeEnd  |    ✅     | Performance measurement via `time.Now` / `time.Since` |
 | assert                |    ✅     | Transpiled to `panic` on failure                      |
 | parseInt / parseFloat |    ✅     | Mapped to Go's `strconv` package                      |
+| JSON.stringify        |    ✅     | Mapped to `encoding/json` `Marshal` / `MarshalIndent` |
+| JSON.parse            |    ✅     | Mapped to `encoding/json` `Unmarshal`                 |
+| Object.keys/values    |    ✅     | Map key/value iteration helpers                       |
+| process.argv          |    ✅     | Mapped to `os.Args`                                   |
+| process.platform      |    ✅     | Mapped to `runtime.GOOS`                              |
+| process.exit          |    ✅     | Mapped to `os.Exit`                                   |
 
 **Math Methods**
 
@@ -116,6 +132,9 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | 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`                  |
+| Math.log / log2 / log10   |    ✅     | Mapped to `math.Log`, `math.Log2`, `math.Log10`   |
+| Math.sin / cos / tan      |    ✅     | Mapped to `math.Sin`, `math.Cos`, `math.Tan`      |
+| Math.trunc / sign         |    ✅     | Mapped to `math.Trunc` and inline sign check      |
 
 **String Methods**
 
@@ -129,6 +148,9 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | replace / replaceAll       |    ✅     | Via `strings` package                         |
 | charAt / substring / slice |    ✅     | Direct Go string indexing/slicing             |
 | concat / repeat            |    ✅     | String concatenation and `strings.Repeat`     |
+| padStart / padEnd          |    ✅     | Via `strings.Repeat`                          |
+| match / matchAll / search  |    ✅     | Via `regexp` package                          |
+| at                         |    ✅     | Supports negative indices                     |
 
 **Number / Object Methods**
 
@@ -147,12 +169,15 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 
 **Modules & Imports**
 
-| Feature                  | Supported | Notes                                                        |
-| ------------------------ | :-------: | ------------------------------------------------------------ |
-| Local file imports       |    ✅     | `import { x } from './file'` transpiled to Go package import |
-| Node.js built-in imports |    ✅     | `import { join } from 'node:path'` mapped to Go stdlib       |
-| Go package imports       |    ✅     | `import { x } from 'go:pkg'`                                 |
-| npm package imports      |    ✅     | `import { x } from 'pkg'` mapped to Go module imports        |
-| Named exports            |    ✅     | `export function` / `export const` declarations              |
+| Feature                  | Supported | Notes                                                              |
+| ------------------------ | :-------: | ------------------------------------------------------------------ |
+| Named imports            |    ✅     | `import { x } from './file'`                                       |
+| Default imports          |    ✅     | `import x from 'pkg'` — namespace stripped in output               |
+| Namespace imports        |    ✅     | `import * as x from 'pkg'`                                         |
+| Local file imports       |    ✅     | Relative paths transpiled to a separate Go file                    |
+| Node.js built-in imports |    ✅     | `import { join } from 'node:path'` mapped to Go stdlib             |
+| Go package imports       |    ✅     | `import { x } from 'go:pkg'`                                       |
+| npm package imports      |    ✅     | `import { x } from 'pkg'` mapped to Go module imports              |
+| Named exports            |    ✅     | `export function` / `export const` declarations                    |
 
 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/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();
@@ -19,6 +28,10 @@ const enumNames = new Set();
 const enumBaseTypes = new Map();
 // 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)
@@ -30,6 +43,9 @@ let currentFileDir = null;
 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;
@@ -52,6 +68,9 @@ export function transpileToNative(code, options) {
     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');
     const main = `package main
@@ -117,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)) {
@@ -137,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)) {
@@ -197,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');
@@ -212,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)) {
@@ -258,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{}';
@@ -458,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);
@@ -520,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();
@@ -565,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)
@@ -585,7 +731,8 @@ export function visit(node, options = {}) {
     }
     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);
@@ -603,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) {
@@ -963,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,
@@ -987,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;
@@ -1039,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);
@@ -1292,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 = {
@@ -1355,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) => {
@@ -1422,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})`;
@@ -1433,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] ?? '""'})`;
@@ -1442,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]}`,
@@ -1578,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;
@@ -1952,6 +2333,17 @@ function visitImportDeclaration(node) {
             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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typenative",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "Build native applications using Typescript.",
   "type": "module",
   "bin": {
@@ -40,7 +40,10 @@
     "test25": "node ./bin/index --source test/Test25.spec.ts --script",
     "test25_export": "node ./bin/index --source test/Test25-export.spec.ts --script",
     "test26": "node ./bin/index --source test/Test26.spec.ts --script",
-    "test27": "node ./bin/index --source test/Test27.spec.ts --script"
+    "test27": "node ./bin/index --source test/Test27.spec.ts --script",
+    "test28": "node ./bin/index --source test/test28.spec.ts --script",
+    "test29": "node ./bin/index --source test/test29.spec.ts --script",
+    "test30": "node ./bin/index --source test/test30.spec.ts --script"
   },
   "repository": {
     "type": "git",

package/types/typenative.d.ts

@@ -99,6 +99,26 @@ interface Array<T> extends IterableIterator<T> {
    * 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 element that satisfies the callback, or -1.
+   */
+  findIndex(callback: (value: T, index?: number, array?: T[]) => boolean): number;
+  /**
+   * Determines whether all elements satisfy the callback.
+   */
+  every(callback: (value: T, index?: number, array?: T[]) => boolean): boolean;
+  /**
+   * Performs the callback for each element.
+   */
+  forEach(callback: (value: T, index?: number, array?: T[]) => void): void;
+  /**
+   * Calls the callback function on each element of the array, accumulating a result.
+   */
+  reduce<U>(
+    callback: (accumulator: U, value: T, index?: number, array?: T[]) => U,
+    initialValue: U
+  ): U;
+  reduce(callback: (accumulator: T, value: T, index?: number, array?: T[]) => T): T;
   /**
    * Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
    */
@@ -107,6 +127,38 @@ interface Array<T> extends IterableIterator<T> {
    * Determines whether an array includes a certain element.
    */
   includes(searchElement: T): boolean;
+  /**
+   * Removes the last element from an array and returns it.
+   */
+  pop(): T | undefined;
+  /**
+   * Removes the first element from an array and returns it.
+   */
+  shift(): T | undefined;
+  /**
+   * Inserts elements at the beginning of an array.
+   */
+  unshift(...items: T[]): number;
+  /**
+   * Reverses the elements of an array in place.
+   */
+  reverse(): T[];
+  /**
+   * Sorts the elements of an array in place.
+   */
+  sort(compareFn?: (a: T, b: T) => number): T[];
+  /**
+   * Returns a new array formed by applying callback to each element and then flattening.
+   */
+  flat(): T[];
+  /**
+   * Merges two or more arrays.
+   */
+  concat(...items: T[]): T[];
+  /**
+   * Returns the element at the given index (supports negative indices).
+   */
+  at(index: number): T | undefined;
   /**
    * Returns a string representation of an array.
    */
@@ -152,6 +204,18 @@ interface String {
   repeat(count: number): string;
   /** Concatenates strings. */
   concat(...strings: string[]): string;
+  /** Pads the start of a string with another string to a total length. */
+  padStart(targetLength: number, padString?: string): string;
+  /** Pads the end of a string with another string to a total length. */
+  padEnd(targetLength: number, padString?: string): string;
+  /** Matches a string against a regex and returns the matches. */
+  match(regexp: string | RegExp): string[] | null;
+  /** Matches all occurrences of a regex. */
+  matchAll(regexp: string | RegExp): string[][];
+  /** Searches for a match and returns the index. */
+  search(regexp: string | RegExp): number;
+  /** Returns the element at the given index (supports negative indices). */
+  at(index: number): string | undefined;
   /** Returns a string representation. */
   toString(): string;
   [index: number]: string;
@@ -159,6 +223,7 @@ interface String {
 
 interface Console {
   log(...data: any[]): void;
+  error(...data: any[]): void;
   time(label?: string): void;
   timeEnd(label?: string): void;
 }
@@ -174,11 +239,44 @@ interface Math {
   min(a: number, b: number): number;
   sqrt(x: number): number;
   pow(base: number, exponent: number): number;
+  log(x: number): number;
+  log2(x: number): number;
+  log10(x: number): number;
+  sin(x: number): number;
+  cos(x: number): number;
+  tan(x: number): number;
+  trunc(x: number): number;
+  sign(x: number): number;
 }
 declare var Math: Math;
 
-declare function parseInt(s: string): number;
+declare function parseInt(s: string, radix?: number): number;
 declare function parseFloat(s: string): number;
+declare function String(value: any): string;
+declare function Number(value: any): number;
+declare function Boolean(value: any): boolean;
+
+interface JSON {
+  stringify(value: any, replacer?: any, space?: number | string): string;
+  parse(text: string): any;
+}
+declare var JSON: JSON;
+
+interface ObjectConstructor {
+  keys(obj: any): string[];
+  values(obj: any): any[];
+  entries(obj: any): [string, any][];
+}
+declare var Object: ObjectConstructor;
+
+interface Process {
+  argv: string[];
+  platform: string;
+  exit(code?: number): never;
+  cwd(): string;
+  env: { [key: string]: string | undefined };
+}
+declare var process: Process;
 
 interface Promise<T> {
   then(callback: (value: T) => void): void;

package/TODO.md

@@ -1,29 +0,0 @@
-**index.ts needs:**
-
-| Feature                         | Example                                                             |
-| ------------------------------- | ------------------------------------------------------------------- |
-| Default imports                 | `import inquirer from 'inquirer'`, `import fs from 'fs-extra'`      |
-| `process` global                | `process.argv`, `process.platform`                                  |
-| Array `findIndex`               | `process.argv.findIndex(a => a === '--script')`                     |
-| `JSON.parse` / `JSON.stringify` | `JSON.parse(fs.readFileSync(...))`, `JSON.stringify(pckg, null, 2)` |
-| Named async IIFE                | `(async function main() { ... })()`                                 |
-
-**transpiler.ts additionally needs:**
-
-| Feature                             | Example                                             |
-| ----------------------------------- | --------------------------------------------------- |
-| Default imports                     | `import ts from 'typescript'`                       |
-| Spread in array literals            | `[...importedPackages]`, `[...arr1, ...arr2]`       |
-| `for...of` with tuple destructuring | `for (const [funcName, fn] of Object.entries(...))` |
-| `Object.entries()`                  | `Object.entries(mapping.functions)`                 |
-| Arrow function IIFE                 | `(() => { ... })()`                                 |
-| Array `findIndex`                   | `parameters.findIndex(p => !!p.initializer)`        |
-
-**Priority order** (most blocking first):
-
-1. **Default imports** — used at the top of both files, nothing runs without this
-2. **Spread in array literals** — used throughout transpiler.ts for array construction
-3. **`for...of` with tuple destructuring + `Object.entries`** — used for iterating import mappings
-4. **`process` global** — core to CLI argument parsing in index.ts
-5. **IIFE** — the entire entry point of index.ts is an async IIFE
-6. **`findIndex`**, **`JSON.parse/stringify`** — utility methods used in both files