typenative 0.1.1 → 0.1.3

package/README.md

@@ -32,7 +32,7 @@ npx typenative --source hello.ts --script
 ## Requirements
 
 - [Node.js v24](https://nodejs.org/en) or newer.
-- [Go 1.26](https://go.dev/doc/install) or newer.
+- [Go 1.26](https://go.dev/doc/install) or newer
 
 ## Install
 
@@ -105,12 +105,15 @@ Scaffolded `tsconfig.json` targets the TypeNative type surface:
 {
   "compilerOptions": {
     "target": "es2020",
-    "strict": true,
-    "types": ["typenative", "typenative/go", "typenative/npm"]
+    "lib": [],
+    "types": ["typenative", "typenative/go", "typenative/npm"],
+    "strict": true
   }
 }
 ```
 
+`lib: []` disables the standard TypeScript libraries, so `typenative`'s own declarations are the entire type surface — the compiler only accepts what actually transpiles.
+
 ## CLI reference
 
 | Flag              | Mode           | Description                                                                                                                                          |
@@ -128,24 +131,30 @@ TypeNative supports a growing subset of TypeScript, not the whole language. The
 
 **Language highlights that work today:**
 
-- `let`/`const`, functions, arrow functions, closures, recursion, rest/spread, default and optional params, destructured params.
-- Classes (inheritance, static members, getters, parameter properties, abstract, `implements`), interfaces, type aliases, generics, enums (numeric + string).
-- `if`/`switch` (incl. fallthrough), `for`/`for...of`/`while`/`do...while`, `try`/`catch`/`finally` (`throw` → `panic`, catch via `defer`/`recover`), ternaries, optional chaining, nullish coalescing, `in`, `typeof`, `instanceof`.
-- `async`/`await`, generators, custom iterators, tagged templates.
+- `let`/`const`, functions, arrow functions, closures, recursion, rest/spread, default and optional params, destructured params, `arguments`.
+- Classes (inheritance, static members/blocks, getters/setters, parameter properties, abstract, `implements`, decorators on classes and methods), interfaces, type aliases, generics (constraints, defaults), namespaces, enums (numeric, string, computed, `const`), tuples.
+- `if`/`switch` (incl. fallthrough), `for`/`for...of`/`for...in`/`while`/`do...while`, labeled loops, `try`/`catch`/`finally` (`throw` → `panic`, catch via `defer`/`recover`), ternaries, optional chaining, nullish coalescing (`??`/`??=`), `in`, `typeof`, `instanceof`, `delete`, logical assignment.
+- `async`/`await`, generators and async generators (`for await`), custom iterators (`*[Symbol.iterator]()`), tagged templates (`String.raw`), `using` (`[Symbol.dispose]`), `new.target`, `import.meta.url`, `import = require` / `export =`, dynamic `import()`.
+- Type system: literal and template-literal types, union/intersection types, conditional types with `infer`, `keyof`/mapped/indexed-access types, utility types (`Partial`, `Readonly`, `Pick`, `Omit`, `Required`, `NonNullable`, `Record`), `as const`, `satisfies`, type guards (`p is T`), assertion functions.
+- Runtime values: `bigint` literals (`2n ** 64n`) and `symbol` keys.
+- JSX: `.tsx` files render to HTML strings.
 
 **Standard library that works today:**
 
-| Area            | What to use                                                                                                                                                                            |
-| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Console         | `console.log`, `assert` (→ `panic` on failure)                                                                                                                                         |
-| `Array`         | `push`/`pop`, `slice`/`splice`, `map`/`filter`/`reduce`, `find`/`some`/`every`, `sort` with comparator, `flat`/`flatMap`, `at`, `entries`, `join`, `reverse`, `shift`/`unshift`        |
-| `Object`        | `assign`, `keys`/`values`/`entries`, spread of records → Go maps                                                                                                                       |
-| `String`        | `split`/`slice`/`replace`, `padStart`/`padEnd`, `repeat`, search/compare, char codes, unicode                                                                                          |
-| `Number`/`Math` | `parseInt`/`parseFloat`, `toFixed`/`toString(radix)`, `isInteger`/`isNaN`, `min`/`max`/`random`                                                                                        |
-| `Map`/`Set`     | Full `set`/`get`/`has`/`delete`/`size` plus `for...of` iteration (→ Go maps)                                                                                                           |
-| `JSON`          | `parse` / `stringify`                                                                                                                                                                  |
-| `RegExp`        | Literals + `new RegExp()`, `test()`, `exec()` with groups, `i`/`m` flags (backreferences, named groups, stateful `/g` loops and lookbehind are not supported — Go `regexp` limitation) |
-| `process`       | `argv` (→ `os.Args`), `platform` (→ `runtime.GOOS`), `env`                                                                                                                             |
+| Area            | What to use                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Console         | `console.log`/`error`/`warn`, `console.time`/`timeEnd`, `assert` (→ `panic` on failure)                                                                                                                                                                                                                                                                                                                                         |
+| `Array`         | `push`/`pop`, `shift`/`unshift`, `slice`/`splice`/`concat`, `map`/`filter`/`reduce`/`reduceRight`, `find`/`findLast`/`findIndex`/`findLastIndex`, `some`/`every`/`forEach`/`includes`/`indexOf`/`lastIndexOf`, `sort` with comparator, `flat`/`flatMap`, `fill`, `at`, `entries`, `join`, `reverse`, change-by-copy (`toSorted`/`toReversed`/`toSpliced`/`with`/`copyWithin`), `Array.from`, `Array.isArray`, `new Array<T>(n)` |
+| `Object`        | `assign`, `keys`/`values`/`entries`, `fromEntries`, `hasOwn`, `defineProperty`, `getOwnPropertyNames`, integrity (`freeze`/`seal`/`preventExtensions` + `isFrozen`/`isSealed`/`isExtensible`), spread of records → Go maps                                                                                                                                                                                                      |
+| `String`        | `split`/`slice`/`replace`/`replaceAll`, `padStart`/`padEnd`, `repeat`, `match`/`matchAll`/`search`, `includes`/`startsWith`/`endsWith`, `indexOf`/`lastIndexOf`, char codes (`charAt`/`charCodeAt`/`fromCharCode`), `at`, `trim`/`trimStart`/`trimEnd`, `normalize`, `localeCompare`, `String.raw`                                                                                                                              |
+| `Number`/`Math` | `parseInt`/`parseFloat`, `toFixed`/`toPrecision`/`toString(radix)`, `Number.isInteger`/`isNaN`/`isFinite` + `MAX_SAFE_INTEGER` & friends, full `Math` (trig, hyperbolic, `log*`, `cbrt`/`hypot`, `min`/`max` incl. spread, constants)                                                                                                                                                                                           |
+| `Map`/`Set`     | Full `set`/`get`/`has`/`delete`/`clear`/`size`, `forEach`, `keys`/`values`, `for...of` iteration (→ ordered Go maps), Set operations (`union`/`intersection`/`difference`/`symmetricDifference`/`isSubsetOf`/`isSupersetOf`/`isDisjointFrom`), `WeakMap`/`WeakSet`                                                                                                                                                              |
+| `Promise`       | `new Promise` (resolve + reject), `then`/`catch`/`finally`, `resolve`/`reject`, `all`/`race`/`allSettled`/`any` (→ goroutines over channels)                                                                                                                                                                                                                                                                                    |
+| `Date`          | `new Date()` / `new Date(ms)`, `getTime`/`valueOf`, local + UTC getters, `toISOString`/`toDateString`/`toTimeString`, `Date.now()`, `Date.UTC()`                                                                                                                                                                                                                                                                                |
+| `JSON`          | `parse` / `stringify`                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `RegExp`        | Literals + `new RegExp()`, `test()`, `exec()` with named groups (`.groups`), flags `i`/`m`/`s`/`g`/`y`/`u`, stateful `lastIndex` for `/g` loops, `source`/`flags`/`global`/... properties. Backreferences, lookahead and lookbehind run on a small backtracking engine (RE2 does not support them)                                                                                                                              |
+| Globals         | `setTimeout`/`clearTimeout`, `setInterval`/`clearInterval`, `queueMicrotask`, `structuredClone`, `globalThis`, `encodeURIComponent`/`decodeURIComponent`, `isNaN`/`isFinite`, `NaN`/`Infinity`                                                                                                                                                                                                                                  |
+| `process`       | `argv` (→ `os.Args`), `platform` (→ Node-style names), `env`, `cwd`, `exit`                                                                                                                                                                                                                                                                                                                                                     |
 
 **Node built-ins (import with the `node:` prefix, mapped to Go helpers):**
 
@@ -160,7 +169,7 @@ fs.readFileSync('file.txt', 'utf-8');
 childProcess.spawnSync('go', ['version'], { encoding: 'utf-8' });
 ```
 
-Supported: `node:path` (`join`, `dirname`, `basename`, `extname`, `resolve`), `node:fs` (`read/write/append/exists/mkdir/readdir/copy/rm`), `node:os` (`platform`, `homedir`, `tmpdir`), `node:child_process` (sync `exec`/`execSync`/`spawnSync`/`spawnInherit` shape). `node:readline.question()` exists as a TypeNative sync extension for self-hosted prompts.
+Supported: `node:path` (`join`, `dirname`, `basename`, `extname`, `resolve`), `node:fs` (`read`/`write`/`append`/`exists`/`mkdir`/`readdir`/`copy`/`rm`/`unlink`), `node:url` (`fileURLToPath`, `pathToFileURL`), `node:os` (`platform`, `homedir`, `tmpdir`), `node:child_process` (sync `exec`, `execSync`, and `spawnSync` shaped like Node's `{ stdout, stderr, status }`; pass `{ stdio: 'inherit' }` to run with the parent's stdio or `{ input }` to pipe stdin). `node:readline.question()` exists as a TypeNative sync extension for self-hosted prompts.
 
 **Direct Go access (import with the `go:` prefix):**
 
@@ -171,7 +180,7 @@ import { ToUpper } from 'go:strings';
 Println(Sprintf('hi %s', ToUpper('bob')));
 ```
 
-Supported: `go:fmt` (`Println`, `Sprintf`), `go:strings` (`ToUpper`, `ToLower`), `go:strconv` (`FormatBool`).
+Any Go package can be imported this way (`import { X } from 'go:pkg'` → `pkg.X`); the typed subset declared for typechecking is `go:fmt` (`Println`, `Sprintf`), `go:strings` (`ToUpper`, `ToLower`), `go:strconv` (`FormatBool`).
 
 **npm packages:**
 

package/bin/index.js

@@ -12,241 +12,279 @@ import * as childProcess from 'node:child_process';
 import { transpileToNative } from './transpiler.js';
 // Run a command and capture its output. Uses Node's spawnSync under Node and a
 // Go helper (os/exec) once transpiled — both synchronous, same result shape.
+// dist/go.mod + dist/tnvendor/x-text: golang.org/x/text's transform and unicode/norm
+// packages, copied from GOROOT/src/vendor (no network needed)
+function vendorXText() {
+  const goroot = runCommand('go', ['env', 'GOROOT']).stdout.trim();
+  const source = path.join(goroot, 'src', 'vendor', 'golang.org', 'x', 'text');
+  for (const pkg of ['transform', path.join('unicode', 'norm')]) {
+    const target = path.join('dist', 'tnvendor', 'x-text', pkg);
+    fs.mkdirSync(target, { recursive: true });
+    for (const file of fs.readdirSync(path.join(source, pkg))) {
+      if (file.endsWith('.go') && !file.endsWith('_test.go')) {
+        fs.writeFileSync(
+          path.join(target, file),
+          fs.readFileSync(path.join(source, pkg, file), 'utf-8')
+        );
+      }
+    }
+  }
+  fs.writeFileSync(
+    path.join('dist', 'tnvendor', 'x-text', 'go.mod'),
+    'module golang.org/x/text\n\ngo 1.23\n'
+  );
+  fs.writeFileSync(
+    path.join('dist', 'go.mod'),
+    'module tnapp\n\ngo 1.23\n\nrequire golang.org/x/text v0.0.0\n\nreplace golang.org/x/text => ./tnvendor/x-text\n'
+  );
+}
 export function runCommand(name, args) {
-    const result = childProcess.spawnSync(name, args, { encoding: 'utf-8' });
-    return { stdout: result.stdout, stderr: result.stderr, status: result.status };
+  const result = childProcess.spawnSync(name, args, { encoding: 'utf-8' });
+  return { stdout: result.stdout, stderr: result.stderr, status: result.status };
 }
 // Run a command with the parent's stdio, returns the exit code.
 export function runInherit(name, args = []) {
-    const result = childProcess.spawnSync(name, args, { stdio: 'inherit' });
-    return result.status;
+  const result = childProcess.spawnSync(name, args, { stdio: 'inherit' });
+  return result.status;
 }
 export function createProject(projectName, installDependencies) {
-    fs.mkdirSync(projectName, { recursive: true });
-    fs.writeFileSync(path.join(projectName, 'main.ts'), `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`);
-    fs.writeFileSync(path.join(projectName, 'tsconfig.json'), getTsConfig());
-    fs.writeFileSync(path.join(projectName, 'package.json'), getPackageJson(projectName));
-    fs.writeFileSync(path.join(projectName, '.gitignore'), getGitIgnore());
-    fs.writeFileSync(path.join(projectName, 'README.md'), getReadMe(projectName));
-    console.log(`Project "${projectName}" created successfully!`);
-    if (installDependencies) {
-        console.log('Installing dependencies...');
-        // npm --prefix avoids needing cwd support in the subprocess binding
-        const result = runCommand('npm', ['install', '--prefix', projectName]);
-        if (result.stdout)
-            console.log(result.stdout.trim());
-        if (result.status !== 0) {
-            if (result.stderr)
-                console.error(result.stderr.trim());
-            process.exit(result.status);
-        }
-        console.log('Dependencies installed successfully!');
+  fs.mkdirSync(projectName, { recursive: true });
+  fs.writeFileSync(
+    path.join(projectName, 'main.ts'),
+    `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`
+  );
+  fs.writeFileSync(path.join(projectName, 'tsconfig.json'), getTsConfig());
+  fs.writeFileSync(path.join(projectName, 'package.json'), getPackageJson(projectName));
+  fs.writeFileSync(path.join(projectName, '.gitignore'), getGitIgnore());
+  fs.writeFileSync(path.join(projectName, 'README.md'), getReadMe(projectName));
+  console.log(`Project "${projectName}" created successfully!`);
+  if (installDependencies) {
+    console.log('Installing dependencies...');
+    // npm --prefix avoids needing cwd support in the subprocess binding
+    const result = runCommand('npm', ['install', '--prefix', projectName]);
+    if (result.stdout) console.log(result.stdout.trim());
+    if (result.status !== 0) {
+      if (result.stderr) console.error(result.stderr.trim());
+      process.exit(result.status);
     }
+    console.log('Dependencies installed successfully!');
+  }
 }
 export function run(opts) {
-    const sourcePath = opts.tsCode ? null : opts.source;
-    const tsCode = opts.tsCode ? opts.tsCode : fs.readFileSync(sourcePath, 'utf-8');
-    const sourceDir = sourcePath ? path.dirname(path.resolve(sourcePath)) : null;
-    const transpileOptions = { parse: opts.parse };
-    if (sourceDir) {
-        transpileOptions.readFile = (specifier, fromDir) => {
-            const baseDir = fromDir ?? sourceDir;
-            // Relative or absolute path → resolve from baseDir
-            if (specifier.startsWith('.') || specifier.startsWith('/')) {
-                // ES convention: ./x.js may refer to x.ts
-                const tsSpecifier = specifier.endsWith('.js')
-                    ? specifier.replace(/\.js$/, '.ts')
-                    : specifier;
-                for (const candidate of [tsSpecifier + '.ts', tsSpecifier, specifier]) {
-                    try {
-                        const fullPath = path.resolve(baseDir, candidate);
-                        return {
-                            content: fs.readFileSync(fullPath, 'utf-8'),
-                            dir: path.dirname(fullPath)
-                        };
-                    }
-                    catch {
-                        /* not found */
-                    }
-                }
-                return null;
-            }
-            // npm package — walk up from baseDir looking for node_modules/<name>
-            const resolved = resolveNpmPackage(baseDir, specifier);
-            if (!resolved)
-                return null;
-            let { content, dir } = resolved;
-            // Normalize CommonJS to ES module syntax
-            if (!content.includes('export ') &&
-                (content.includes('module.exports') || content.includes('exports.'))) {
-                content = normalizeCjsContent(content);
-            }
-            // Inject types from a local ambient .d.ts if available
-            const typed = tryInjectDtsTypes(content, specifier, sourceDir);
-            if (typed)
-                content = typed;
-            return { content, dir };
-        };
-    }
-    const transpileResult = transpileToNative(tsCode, transpileOptions);
-    const exeName = platform() === 'win32' ? 'native.exe' : 'native';
-    const exePath = `dist/${exeName}`;
-    fs.mkdirSync('dist', { recursive: true });
-    // Clean up stale Go files from previous runs before writing new ones
-    for (const existing of fs.readdirSync('dist')) {
-        if (existing.endsWith('.go'))
-            fs.rmSync(`dist/${existing}`);
-    }
-    fs.writeFileSync('dist/code.go', transpileResult.main);
-    const goFiles = ['dist/code.go'];
-    for (const [filename, content] of transpileResult.files) {
-        fs.writeFileSync(`dist/${filename}`, content);
-        goFiles.push(`dist/${filename}`);
-    }
-    const buildResult = runCommand('go', ['build', '-o', exePath, ...goFiles]);
-    if (buildResult.status !== 0) {
-        console.error('go build failed:');
-        if (buildResult.stderr)
-            console.error(buildResult.stderr.trim());
-        process.exit(1);
-    }
-    if (opts.scriptMode) {
-        process.exit(runInherit(exePath));
-    }
-    else if (opts.output) {
-        fs.copyFileSync(exePath, opts.output);
-        console.log(`Created native executable at: ${opts.output}`);
-    }
+  const sourcePath = opts.tsCode ? null : opts.source;
+  const tsCode = opts.tsCode ? opts.tsCode : fs.readFileSync(sourcePath, 'utf-8');
+  const sourceDir = sourcePath ? path.dirname(path.resolve(sourcePath)) : null;
+  const transpileOptions = { parse: opts.parse, tsx: !!sourcePath && sourcePath.endsWith('.tsx') };
+  if (sourceDir) {
+    transpileOptions.readFile = (specifier, fromDir) => {
+      const baseDir = fromDir ?? sourceDir;
+      // Relative or absolute path → resolve from baseDir
+      if (specifier.startsWith('.') || specifier.startsWith('/')) {
+        // ES convention: ./x.js may refer to x.ts
+        const tsSpecifier = specifier.endsWith('.js')
+          ? specifier.replace(/\.js$/, '.ts')
+          : specifier;
+        const tsxSpecifier = specifier.endsWith('.js')
+          ? specifier.replace(/\.js$/, '.tsx')
+          : specifier + '.tsx';
+        for (const candidate of [tsSpecifier + '.ts', tsxSpecifier, tsSpecifier, specifier]) {
+          try {
+            const fullPath = path.resolve(baseDir, candidate);
+            return {
+              content: fs.readFileSync(fullPath, 'utf-8'),
+              dir: path.dirname(fullPath),
+              tsx: fullPath.endsWith('.tsx')
+            };
+          } catch {
+            /* not found */
+          }
+        }
+        return null;
+      }
+      // npm package — walk up from baseDir looking for node_modules/<name>
+      const resolved = resolveNpmPackage(baseDir, specifier);
+      if (!resolved) return null;
+      let { content, dir } = resolved;
+      // Normalize CommonJS to ES module syntax
+      if (
+        !content.includes('export ') &&
+        (content.includes('module.exports') || content.includes('exports.'))
+      ) {
+        content = normalizeCjsContent(content);
+      }
+      // Inject types from a local ambient .d.ts if available
+      const typed = tryInjectDtsTypes(content, specifier, sourceDir);
+      if (typed) content = typed;
+      return { content, dir };
+    };
+  }
+  const transpileResult = transpileToNative(tsCode, transpileOptions);
+  const exeName = platform() === 'win32' ? 'native.exe' : 'native';
+  const exePath = `dist/${exeName}`;
+  fs.mkdirSync('dist', { recursive: true });
+  // Clean up stale Go files from previous runs before writing new ones
+  for (const existing of fs.readdirSync('dist')) {
+    if (existing.endsWith('.go') || existing === 'go.mod' || existing === 'go.sum')
+      fs.rmSync(`dist/${existing}`);
+  }
+  fs.writeFileSync('dist/code.go', transpileResult.main);
+  const goFiles = ['dist/code.go'];
+  for (const [filename, content] of transpileResult.files) {
+    fs.writeFileSync(`dist/${filename}`, content);
+    goFiles.push(`dist/${filename}`);
+  }
+  // golang.org/x/text (String.normalize) comes from the copy vendored in GOROOT
+  const xTextImport = /^import (\w+ )?"golang\.org\/x\/text\//m;
+  let usesXText = xTextImport.test(transpileResult.main);
+  for (const content of transpileResult.files.values()) {
+    if (xTextImport.test(content)) usesXText = true;
+  }
+  if (usesXText) vendorXText();
+  const buildResult = usesXText
+    ? runCommand('go', [
+        'build',
+        '-C',
+        'dist',
+        '-o',
+        exeName,
+        ...goFiles.map((f) => f.slice('dist/'.length))
+      ])
+    : runCommand('go', ['build', '-o', exePath, ...goFiles]);
+  if (buildResult.status !== 0) {
+    console.error('go build failed:');
+    if (buildResult.stderr) console.error(buildResult.stderr.trim());
+    process.exit(1);
+  }
+  if (opts.scriptMode) {
+    process.exit(runInherit(exePath));
+  } else if (opts.output) {
+    fs.copyFileSync(exePath, opts.output);
+    console.log(`Created native executable at: ${opts.output}`);
+  }
 }
 function normalizeCjsContent(code) {
-    code = code.replace(/['"]use strict['"];?\n?/g, '');
-    code = code.replace(/(?:module\.exports|exports)\.(\w+)\s*=\s*function\s*\w*\s*\(/g, 'export function $1(');
-    return code;
+  code = code.replace(/['"]use strict['"];?\n?/g, '');
+  code = code.replace(
+    /(?:module\.exports|exports)\.(\w+)\s*=\s*function\s*\w*\s*\(/g,
+    'export function $1('
+  );
+  return code;
 }
 function tryInjectDtsTypes(jsContent, packageName, searchDir) {
-    if (!searchDir)
-        return null;
-    // Look for *.d.ts files in searchDir that declare the module
-    let dtsBody = null;
-    try {
-        const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        for (const file of fs.readdirSync(searchDir)) {
-            if (!file.endsWith('.d.ts'))
-                continue;
-            const content = fs.readFileSync(path.join(searchDir, file), 'utf-8');
-            const match = content.match(new RegExp(`declare module ['"]${escaped}['"][^{]*\\{([\\s\\S]*?)\\}`));
-            if (match) {
-                dtsBody = match[1];
-                break;
-            }
-        }
+  if (!searchDir) return null;
+  // Look for *.d.ts files in searchDir that declare the module
+  let dtsBody = null;
+  try {
+    const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    for (const file of fs.readdirSync(searchDir)) {
+      if (!file.endsWith('.d.ts')) continue;
+      const content = fs.readFileSync(path.join(searchDir, file), 'utf-8');
+      const match = content.match(
+        new RegExp(`declare module ['"]${escaped}['"][^{]*\\{([\\s\\S]*?)\\}`)
+      );
+      if (match) {
+        dtsBody = match[1];
+        break;
+      }
     }
-    catch {
-        return null;
-    }
-    if (!dtsBody)
-        return null;
-    // Extract typed function signatures from the .d.ts module body
-    const signatures = new Map();
-    const sigRegex = /export function (\w+)\(([^)]*)\)\s*:\s*([^\n;]+)/g;
-    for (const m of dtsBody.matchAll(sigRegex)) {
-        signatures.set(m[1], { params: m[2].trim(), returnType: m[3].trim() });
-    }
-    if (signatures.size === 0)
-        return null;
-    // Replace untyped signatures in the normalized JS with typed ones from .d.ts
-    return jsContent.replace(/export function (\w+)\s*\(([^)]*)\)/g, (match, name) => {
-        const sig = signatures.get(name);
-        if (!sig)
-            return match;
-        return `export function ${name}(${sig.params}): ${sig.returnType}`;
-    });
+  } catch {
+    return null;
+  }
+  if (!dtsBody) return null;
+  // Extract typed function signatures from the .d.ts module body
+  const signatures = new Map();
+  const sigRegex = /export function (\w+)\(([^)]*)\)\s*:\s*([^\n;]+)/g;
+  for (const m of dtsBody.matchAll(sigRegex)) {
+    signatures.set(m[1], { params: m[2].trim(), returnType: m[3].trim() });
+  }
+  if (signatures.size === 0) return null;
+  // Replace untyped signatures in the normalized JS with typed ones from .d.ts
+  return jsContent.replace(/export function (\w+)\s*\(([^)]*)\)/g, (match, name) => {
+    const sig = signatures.get(name);
+    if (!sig) return match;
+    return `export function ${name}(${sig.params}): ${sig.returnType}`;
+  });
 }
 function resolveNpmPackage(fromDir, packageName) {
-    // Walk up the directory tree looking for node_modules/<packageName>
-    let searchDir = fromDir;
-    while (true) {
-        const pkgDir = path.join(searchDir, 'node_modules', packageName);
-        const pkgJsonPath = path.join(pkgDir, 'package.json');
-        try {
-            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
-            // Build candidate entry points: TypeScript preferred, JavaScript as fallback
-            const tsCandidates = [];
-            const jsCandidates = [];
-            for (const field of ['source', 'main', 'module']) {
-                const entry = pkgJson[field];
-                if (!entry)
-                    continue;
-                if (entry.endsWith('.ts'))
-                    tsCandidates.push(entry);
-                else if (entry.endsWith('.js')) {
-                    tsCandidates.push(entry.replace(/\.js$/, '.ts'));
-                    jsCandidates.push(entry);
-                }
-            }
-            tsCandidates.push('index.ts', 'src/index.ts');
-            jsCandidates.push('index.js', 'src/index.js');
-            const candidates = [...tsCandidates, ...jsCandidates];
-            for (const candidate of candidates) {
-                const fullPath = path.resolve(pkgDir, candidate);
-                try {
-                    return { content: fs.readFileSync(fullPath, 'utf-8'), dir: path.dirname(fullPath) };
-                }
-                catch {
-                    /* try next candidate */
-                }
-            }
+  // Walk up the directory tree looking for node_modules/<packageName>
+  let searchDir = fromDir;
+  while (true) {
+    const pkgDir = path.join(searchDir, 'node_modules', packageName);
+    const pkgJsonPath = path.join(pkgDir, 'package.json');
+    try {
+      const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+      // Build candidate entry points: TypeScript preferred, JavaScript as fallback
+      const tsCandidates = [];
+      const jsCandidates = [];
+      for (const field of ['source', 'main', 'module']) {
+        const entry = pkgJson[field];
+        if (!entry) continue;
+        if (entry.endsWith('.ts')) tsCandidates.push(entry);
+        else if (entry.endsWith('.js')) {
+          tsCandidates.push(entry.replace(/\.js$/, '.ts'));
+          jsCandidates.push(entry);
         }
-        catch {
-            /* no package.json here, keep walking up */
+      }
+      tsCandidates.push('index.ts', 'src/index.ts');
+      jsCandidates.push('index.js', 'src/index.js');
+      const candidates = [...tsCandidates, ...jsCandidates];
+      for (const candidate of candidates) {
+        const fullPath = path.resolve(pkgDir, candidate);
+        try {
+          return { content: fs.readFileSync(fullPath, 'utf-8'), dir: path.dirname(fullPath) };
+        } catch {
+          /* try next candidate */
         }
-        const parent = path.dirname(searchDir);
-        if (parent === searchDir)
-            break; // filesystem root
-        searchDir = parent;
+      }
+    } catch {
+      /* no package.json here, keep walking up */
     }
-    return null;
+    const parent = path.dirname(searchDir);
+    if (parent === searchDir) break; // filesystem root
+    searchDir = parent;
+  }
+  return null;
 }
 function getPackageJson(projectName) {
-    const exeName = platform() === 'win32' ? `${projectName}.exe` : projectName;
-    const pckg = {
-        name: projectName,
-        version: '1.0.0',
-        scripts: {
-            execute: 'npx typenative --source main.ts --script',
-            build: `npx typenative --source main.ts --output bin/${exeName}`
-        },
-        devDependencies: {
-            typenative: '^0.1.1'
-        }
-    };
-    return JSON.stringify(pckg, null, 2);
+  const exeName = platform() === 'win32' ? `${projectName}.exe` : projectName;
+  const pckg = {
+    name: projectName,
+    version: '1.0.0',
+    scripts: {
+      execute: 'npx typenative --source main.ts --script',
+      build: `npx typenative --source main.ts --output bin/${exeName}`
+    },
+    devDependencies: {
+      typenative: '^0.1.3'
+    }
+  };
+  return JSON.stringify(pckg, null, 2);
 }
 function getTsConfig() {
-    const tsConfig = {
-        include: ['**/*.ts'],
-        compilerOptions: {
-            target: 'es2020',
-            lib: [],
-            types: ['typenative', 'typenative/go', 'typenative/npm'],
-            rootDir: '.',
-            strict: true,
-            noImplicitAny: true,
-            allowSyntheticDefaultImports: true
-        }
-    };
-    return JSON.stringify(tsConfig, null, 2);
+  const tsConfig = {
+    include: ['**/*.ts'],
+    compilerOptions: {
+      target: 'es2020',
+      lib: [],
+      types: ['typenative', 'typenative/go', 'typenative/npm'],
+      rootDir: '.',
+      strict: true,
+      noImplicitAny: true,
+      allowSyntheticDefaultImports: true
+    }
+  };
+  return JSON.stringify(tsConfig, null, 2);
 }
 function getGitIgnore() {
-    return `# TypeNative generated files
+  return `# TypeNative generated files
 node_modules/
 dist/
 bin/
 `;
 }
 function getReadMe(projectName) {
-    const exeName = platform() === 'win32' ? `${projectName}.exe` : projectName;
-    return `# ${projectName}
+  const exeName = platform() === 'win32' ? `${projectName}.exe` : projectName;
+  return `# ${projectName}
 
 This project was created using TypeNative, a tool to transpile TypeScript code to native Go code.
 

package/bin/parse-native.js

@@ -4,9 +4,10 @@
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import * as childProcess from 'node:child_process';
-export function parseAstJsonNative(code) {
+export function parseAstJsonNative(code, tsx) {
     const exe = findTsparser();
-    const result = childProcess.spawnSync(exe, [], { input: code, encoding: 'utf-8' });
+    const args = tsx ? ['--tsx'] : [];
+    const result = childProcess.spawnSync(exe, args, { input: code, encoding: 'utf-8' });
     if (result.status !== 0) {
         throw new Error('tsparser failed: ' + result.stderr);
     }