tsnite 0.1.5 → 0.2.1

package/README.md

@@ -1,11 +1,19 @@
-# tsnite
-
-[![npm version](https://img.shields.io/npm/v/tsnite.svg)](https://www.npmjs.com/package/tsnite)
-[![Eslint](https://img.shields.io/badge/ESLint-3A33D1?logo=eslint)](https://img.shields.io/badge/ESLint-3A33D1?logo=eslint)
-[![prettier](https://img.shields.io/badge/Prettier-de9954?logo=prettier&logoColor=ffffff)](https://img.shields.io/badge/Prettier-de9954?logo=prettier&logoColor=ffffff)
-[![github license](https://img.shields.io/github/license/luas10c/tsnite)](https://img.shields.io/github/license/luas10c/tsnite)
-
-TypeScript runner for Node.js with watch mode, `tsconfig` path alias support, and extensionless TypeScript import resolution.
+<h1 align="center">
+<br>
+<img alt="tsnite" src="https://github.com/luas10c/tsnite/blob/main/tsnite.png?raw=true">
+<br><br>
+<a href="https://npm.im/tsnite"><img src="https://badgen.net/npm/v/tsnite"></a>
+<a href="https://npm.im/tsnite"><img src="https://badgen.net/npm/dm/tsnite"></a>
+<a href="https://npm.im/tsnite"><img src="https://img.shields.io/badge/ESLint-3A33D1?logo=eslint" alt="eslint"></a>
+<a href="https://npm.im/tsnite"><img src="https://img.shields.io/badge/Prettier-21323b?logo=prettier&logoColor=ffffff" alt="prettier"></a>
+<a href="https://npm.im/tsnite"><img src="https://img.shields.io/github/license/luas10c/tsnite" alt="github license"></a>
+</h1>
+
+<p align="center">
+TypeScript at full throttle—fast, safe, unstoppable. 🚀
+<br><br>
+<a href="https://github.com/luas10c/tsnite">Documentation</a>&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;<a href="https://github.com/luas10c/tsnite">Getting started →</a>
+</p>
 
 ## Install
 
@@ -13,7 +21,15 @@ TypeScript runner for Node.js with watch mode, `tsconfig` path alias support, an
 npm install --save-dev tsnite
 ```
 
-## Usage
+## Features
+
+- ESM-friendly runtime
+- Watch mode with automatic restart
+- Supports `compilerOptions.paths`
+- Resolves extensionless TypeScript imports
+- Decorator support
+
+## Quick Start
 
 Run a TypeScript entry file:
 
@@ -44,16 +60,6 @@ Use in `package.json`:
 }
 ```
 
-## Features
-
-- Run `.ts`, `.tsx`, `.mts`, and `.cts` files directly in Node.js
-- Watch mode with automatic restart
-- Reads the current project's `tsconfig.json`
-- Resolves `compilerOptions.paths`
-- Resolves extensionless TypeScript imports
-- ESM-friendly runtime
-- Decorator support in transpilation
-
 ## Import Resolution
 
 `tsnite` resolves TypeScript files without requiring explicit extensions.
@@ -78,29 +84,6 @@ It will try these TypeScript candidates:
 
 Explicit JavaScript imports such as `.js`, `.mjs`, and `.cjs` are delegated to Node.js.
 
-## `tsconfig` Paths
-
-`tsnite` supports `compilerOptions.paths` aliases.
-
-```json
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "#/*": ["src/*"]
-    }
-  }
-}
-```
-
-Then this works without an extension:
-
-```ts
-import { getMetadata } from '#/common/metadata'
-```
-
-If `baseUrl` is not defined, `tsnite` uses the project root by default.
-
 ## Watch Mode
 
 Customize watched paths and extensions:
@@ -123,45 +106,14 @@ Defaults:
 - ext: `ts,tsx,js,jsx,json`
 - source root: `.`
 
-## Example
-
-`tsconfig.json`
-
-```json
-{
-  "compilerOptions": {
-    "target": "es2024",
-    "module": "es2022",
-    "moduleResolution": "bundler",
-    "baseUrl": ".",
-    "paths": {
-      "#/*": ["src/*"]
-    }
-  }
-}
-```
-
-`src/index.ts`
-
-```ts
-import { startServer } from '#/server/start'
-
-await startServer()
-```
-
-Run it:
-
-```bash
-npx tsnite src/index.ts
-```
+## Support
 
-## Notes
+Enjoying this tool? Consider supporting the project.
 
-- `tsnite` is focused on development-time execution
-- the current project's `tsconfig.json` is used
-- watch mode clears cached resolution and transpilation state before restart
+<p>
+  <a href="https://buymeacoffee.com/luas10c" target="_blank" rel="noopener noreferrer"><img src="https://github.com/luas10c/tsnite/blob/main/buymeacoffe.png?raw=true" alt="Buy me a coffee" width="180" /></a>
+</p>
 
-## Links
+## License
 
-- npm: <https://www.npmjs.com/package/tsnite>
-- repository: <https://github.com/luas10c/tsnite>
+[MIT](LICENSE)

package/dist/cache.js

@@ -1,8 +1,7 @@
 import { createHash } from 'node:crypto';
-import { mkdir, rm, stat } from 'node:fs/promises';
+import { mkdir, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 export const resolveCache = new Map();
-const statCache = new Map();
 function getTranspileCacheDir() {
     return join(import.meta.dirname, '..', 'node_modules', '.cache', 'tsnite');
 }
@@ -12,27 +11,9 @@ function getTSConfigPath() {
 function hash(value) {
     return createHash('sha1').update(value).digest('hex');
 }
-export async function existsWithCache(filePath) {
-    const cached = statCache.get(filePath);
-    if (cached)
-        return cached.exists;
-    try {
-        const stats = await stat(filePath);
-        const exists = stats.isFile();
-        statCache.set(filePath, { exists, mtime: stats.mtimeMs });
-        return exists;
-    }
-    catch {
-        statCache.set(filePath, { exists: false });
-        return false;
-    }
-}
 export function clearResolveCache() {
     resolveCache.clear();
 }
-export function invalidateStatCache(filePath) {
-    statCache.delete(filePath);
-}
 export function getTranspileCacheFile(filePath) {
     return join(getTranspileCacheDir(), `${hash(filePath)}.json`);
 }
@@ -46,7 +27,6 @@ export function isTSConfigPath(filePath) {
     return resolve(filePath) === getTSConfigPath();
 }
 export async function invalidateFileCaches(filePath) {
-    invalidateStatCache(filePath);
     clearResolveCache();
     if (isTSConfigPath(filePath)) {
         await clearTranspileCache();

package/dist/cli.js

@@ -6,7 +6,7 @@ import { fork } from 'node:child_process';
 import { watch } from 'chokidar';
 import { name, description, version } from './metadata.js';
 import { clearResolveCache, invalidateFileCaches } from './cache.js';
-import { debounce, yellow } from './util.js';
+import { debounce, cyan, gray, red, yellow } from './util.js';
 const DEFAULT_INCLUDE_PATHS = ['.'];
 const DEFAULT_EXCLUDE_PATHS = ['dist', 'build', 'coverage'];
 const DEFAULT_WATCH_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'json'];
@@ -20,7 +20,7 @@ program
     .version(version, '-v, --version', 'Output the current version')
     .showSuggestionAfterError();
 function cleanup(signal) {
-    process.stdout.write(`${yellow(`Received ${signal}. Stopping watcher and child processes...`)}\n`);
+    process.stdout.write(`${yellow(`Received`)} ${cyan(signal)}${yellow('. Stopping watcher and child processes...')}\n`);
     for (const child of children.values()) {
         try {
             child.kill('SIGTERM');
@@ -37,10 +37,14 @@ process.on('SIGINT', function () {
 process.on('SIGTERM', function () {
     cleanup('SIGTERM');
 });
-function spawn(entry, nodeArgs) {
+function spawn(entry, nodeArgs, shouldLogTranspile) {
     const entryPath = isAbsolute(entry) ? entry : resolve(process.cwd(), entry);
     const child = fork(entryPath, {
         stdio: 'inherit',
+        env: {
+            ...process.env,
+            TSNITE_LOG_TRANSPILE: shouldLogTranspile ? '1' : '0'
+        },
         execArgv: [
             '--enable-source-maps',
             '--no-experimental-strip-types',
@@ -135,7 +139,7 @@ async function handler(entry, options, nodeArgs, isWatch) {
     async function restart(reason) {
         process.stdout.write('\x1Bc');
         if (reason) {
-            console.log(yellow(reason));
+            console.log(gray(reason));
         }
         for (const child of children.values()) {
             try {
@@ -147,7 +151,7 @@ async function handler(entry, options, nodeArgs, isWatch) {
             const exited = await waitForChildExit(child);
             if (exited)
                 continue;
-            console.log(yellow(`${reason ?? 'Restart requested.'} Process hasn't exited. Killing process...`));
+            console.log(`${yellow('restart')} ${gray('process unresponsive, sending')} ${red('SIGKILL')}`);
             try {
                 child.kill('SIGKILL');
             }
@@ -156,14 +160,14 @@ async function handler(entry, options, nodeArgs, isWatch) {
             }
         }
         clearResolveCache();
-        spawn(runtimeEntry, nodeArgs);
+        spawn(runtimeEntry, nodeArgs, isWatch);
     }
     const restartDebounced = debounce(restart, WATCH_DEBOUNCE_MS);
     process.stdout.write('\x1Bc');
     if (isWatch) {
         console.log(yellow('Watching for changes...'));
     }
-    spawn(runtimeEntry, nodeArgs);
+    spawn(runtimeEntry, nodeArgs, isWatch);
     if (!isWatch)
         return;
     const { ignored, paths } = createWatchConfig(options);
@@ -178,8 +182,9 @@ async function handler(entry, options, nodeArgs, isWatch) {
             eventName !== 'unlink') {
             return;
         }
-        await invalidateFileCaches(isAbsolute(changedPath) ? changedPath : (resolve(process.cwd(), changedPath)));
-        restartDebounced(`Change detected (${eventName}): ${changedPath}`);
+        const absoluteChangedPath = isAbsolute(changedPath) ? changedPath : (resolve(process.cwd(), changedPath));
+        await invalidateFileCaches(absoluteChangedPath);
+        restartDebounced();
     });
 }
 function parseCsv(value) {

package/dist/loader.js

@@ -1,72 +1,25 @@
-import { transformFile } from '@swc/core';
+import { transform } from 'oxc-transform';
+import { ResolverFactory } from 'oxc-resolver';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { readFile, stat, writeFile } from 'node:fs/promises';
-import { extname, join, dirname } from 'node:path';
+import { writeSync } from 'node:fs';
+import { relative } from 'node:path';
 import { createHash } from 'node:crypto';
-import { parse } from './parse.js';
-import { ensureTranspileCacheDir, existsWithCache, getTranspileCacheFile, resolveCache } from './cache.js';
-const tsconfigCache = { paths: null, baseUrl: null };
+import { ensureTranspileCacheDir, getTranspileCacheFile, resolveCache } from './cache.js';
+import { gray, green, yellow } from './util.js';
 const transpileCache = new Map();
 const MAX_TRANSPILE_CACHE_ENTRIES = 256;
 const TS_EXTENSIONS = ['.cts', '.mts', '.tsx', '.ts'];
+const SHOULD_LOG_TRANSPILE = process.env.TSNITE_LOG_TRANSPILE === '1';
+const TRANSPILE_CONFIG_HASH = hash('target:es2024|jsx:automatic|decorator:legacy');
+const resolver = new ResolverFactory({
+    conditionNames: ['node', 'import'],
+    extensions: ['.cts', '.mts', '.tsx', '.ts', '.cjs', '.mjs', '.js', '.json'],
+    tsconfig: 'auto'
+});
 function hasTypeScriptExtension(value) {
     return TS_EXTENSIONS.some((extension) => value.endsWith(extension));
 }
-function isTypeScriptSpecifier(specifier) {
-    const extension = extname(specifier);
-    return extension === '' || hasTypeScriptExtension(extension);
-}
-function getTypeScriptTryFiles(basePath) {
-    return [
-        basePath,
-        ...TS_EXTENSIONS.map((extension) => basePath + extension),
-        ...TS_EXTENSIONS.map((extension) => join(basePath, 'index' + extension))
-    ];
-}
-async function resolveTypeScriptFile(basePath) {
-    for (const file of getTypeScriptTryFiles(basePath)) {
-        if (await existsWithCache(file)) {
-            return file;
-        }
-    }
-    return null;
-}
-function matchPathPattern(specifier, pattern) {
-    const starIndex = pattern.indexOf('*');
-    if (starIndex === -1) {
-        return specifier === pattern ? [] : null;
-    }
-    const prefix = pattern.slice(0, starIndex);
-    const suffix = pattern.slice(starIndex + 1);
-    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) {
-        return null;
-    }
-    return [specifier.slice(prefix.length, specifier.length - suffix.length)];
-}
-function applyPathMapping(target, matches) {
-    let mapped = target;
-    for (const match of matches) {
-        mapped = mapped.replace('*', match);
-    }
-    return mapped;
-}
-async function resolveTsConfigPath(specifier, paths, baseUrl) {
-    if (!paths || !baseUrl || !isTypeScriptSpecifier(specifier)) {
-        return null;
-    }
-    for (const [pattern, targets] of Object.entries(paths)) {
-        const matches = matchPathPattern(specifier, pattern);
-        if (!matches)
-            continue;
-        for (const target of targets) {
-            const mappedTarget = applyPathMapping(target, matches);
-            const resolved = await resolveTypeScriptFile(join(baseUrl, mappedTarget));
-            if (resolved)
-                return resolved;
-        }
-    }
-    return null;
-}
 function hash(value) {
     return createHash('sha1').update(value).digest('hex');
 }
@@ -122,42 +75,11 @@ async function writeCachedTranspile(filename, entry) {
         // Ignore cache write failures and continue with fresh output.
     }
 }
-async function loadTSConfig() {
-    if (tsconfigCache.paths !== null && tsconfigCache.baseUrl !== null) {
-        return tsconfigCache;
-    }
-    try {
-        const data = await readFile(join(process.cwd(), 'tsconfig.json'), 'utf-8');
-        const { compilerOptions } = parse(data);
-        const paths = compilerOptions?.paths ?? null;
-        const baseUrl = compilerOptions?.baseUrl;
-        tsconfigCache.paths = paths || null;
-        tsconfigCache.baseUrl =
-            baseUrl ? join(process.cwd(), baseUrl) : process.cwd();
-        return tsconfigCache;
-    }
-    catch {
-        tsconfigCache.paths = null;
-        tsconfigCache.baseUrl = process.cwd();
-        return tsconfigCache;
-    }
-}
 export async function resolve(specifier, ctx, next) {
-    const { paths, baseUrl } = await loadTSConfig();
-    const resolvedTsConfigPath = await resolveTsConfigPath(specifier, paths, baseUrl);
-    if (resolvedTsConfigPath) {
-        const url = pathToFileURL(resolvedTsConfigPath).href;
-        resolveCache.set(`${ctx.parentURL}::${specifier}`, url);
-        return {
-            url,
-            format: 'module',
-            shortCircuit: true
-        };
-    }
-    if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+    if (typeof ctx.parentURL !== 'string') {
         return next(specifier, ctx);
     }
-    if (!isTypeScriptSpecifier(specifier)) {
+    if (ctx.parentURL.startsWith('file://') === false) {
         return next(specifier, ctx);
     }
     const cacheKey = `${ctx.parentURL}::${specifier}`;
@@ -173,28 +95,10 @@ export async function resolve(specifier, ctx, next) {
         };
     }
     const parentPath = fileURLToPath(ctx.parentURL);
-    const parentDir = dirname(parentPath);
-    const basePath = join(parentDir, specifier);
-    const tryFiles = [
-        basePath,
-        basePath + '.ts',
-        basePath + '.tsx',
-        basePath + '.mts',
-        basePath + '.cts',
-        basePath + '.js',
-        basePath + '.mjs',
-        basePath + '.cjs',
-        join(basePath, 'index.ts'),
-        join(basePath, 'index.tsx'),
-        join(basePath, 'index.mts'),
-        join(basePath, 'index.cts'),
-        join(basePath, 'index.js'),
-        join(basePath, 'index.mjs'),
-        join(basePath, 'index.cjs')
-    ];
-    for (const file of tryFiles) {
-        if (await existsWithCache(file)) {
-            const url = pathToFileURL(file).href;
+    try {
+        const result = await resolver.resolveFileAsync(parentPath, specifier);
+        if (result.path) {
+            const url = pathToFileURL(result.path).href;
             resolveCache.set(cacheKey, url);
             return {
                 url,
@@ -203,6 +107,10 @@ export async function resolve(specifier, ctx, next) {
             };
         }
     }
+    catch {
+        resolveCache.set(cacheKey, null);
+        return next(specifier, ctx);
+    }
     resolveCache.set(cacheKey, null);
     return next(specifier, ctx);
 }
@@ -210,54 +118,37 @@ export async function load(url, ctx, next) {
     if (!url.startsWith('file://') || !hasTypeScriptExtension(url)) {
         return next(url, ctx);
     }
-    const { paths, baseUrl } = await loadTSConfig();
     const filename = fileURLToPath(url);
     const fileStats = await stat(filename);
-    const configHash = hash(JSON.stringify({
-        baseUrl: baseUrl || process.cwd(),
-        paths: paths ?? {}
-    }));
-    const cachedCode = await readCachedTranspile(filename, fileStats.mtimeMs, fileStats.size, configHash);
+    const cachedCode = await readCachedTranspile(filename, fileStats.mtimeMs, fileStats.size, TRANSPILE_CONFIG_HASH);
     if (cachedCode !== null) {
         return { format: 'module', source: cachedCode, shortCircuit: true };
     }
-    const { code } = await transformFile(filename, {
-        filename,
-        jsc: {
-            baseUrl: baseUrl || process.cwd(),
-            parser: {
-                syntax: 'typescript',
-                tsx: url.endsWith('.tsx'),
-                decorators: true
-            },
-            target: 'es2022',
-            keepClassNames: true,
-            experimental: {
-                emitAssertForImportAttributes: true
-            },
-            transform: {
-                decoratorMetadata: true,
-                legacyDecorator: true,
-                react: {
-                    runtime: 'automatic',
-                    development: true
-                }
-            },
-            paths: paths ?? {}
-        },
-        module: {
-            type: 'es6',
-            strict: true,
-            outFileExtension: 'ts',
-            resolveFully: true
+    const source = await readFile(filename, 'utf8');
+    const transpileStart = Date.now();
+    const { code } = await transform(filename, source, {
+        jsx: {
+            runtime: 'automatic',
+            development: true
         },
-        sourceMaps: 'inline'
+        sourcemap: true,
+        sourceType: 'module',
+        target: 'es2024',
+        decorator: {
+            emitDecoratorMetadata: true,
+            legacy: true
+        }
     });
+    if (SHOULD_LOG_TRANSPILE) {
+        const transpileTimeMs = Date.now() - transpileStart;
+        const displayPath = relative(process.cwd(), filename);
+        writeSync(1, `${gray('Transpiled')} ${yellow(displayPath)} ${gray('in')} ${green(`${transpileTimeMs}ms`)}\n`);
+    }
     await writeCachedTranspile(filename, {
         code,
         mtimeMs: fileStats.mtimeMs,
         size: fileStats.size,
-        configHash
+        configHash: TRANSPILE_CONFIG_HASH
     });
     return { format: 'module', source: code, shortCircuit: true };
 }

package/dist/util.js

@@ -9,6 +9,39 @@ export function debounce(callback, waitMs) {
 function color(code, value) {
     return `\u001B[${code}m${value}\u001B[0m`;
 }
+function style(codes, value) {
+    return `\u001B[${codes.join(';')}m${value}\u001B[0m`;
+}
 export function yellow(value) {
     return color(33, value);
 }
+export function purple(value) {
+    return color(95, value);
+}
+export function red(value) {
+    return color(31, value);
+}
+export function blue(value) {
+    return color(34, value);
+}
+export function white(value) {
+    return color(97, value);
+}
+export function pink(value) {
+    return color(95, value);
+}
+export function cyan(value) {
+    return color(96, value);
+}
+export function green(value) {
+    return color(32, value);
+}
+export function gray(value) {
+    return color(90, value);
+}
+export function bold(value) {
+    return style([1], value);
+}
+export function accent(value) {
+    return style([1, 36], value);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tsnite",
   "description": "TypeScript at full throttle—fast, safe, unstoppable. 🚀",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "keywords": [
     "cli",
     "esm",
@@ -20,7 +20,6 @@
   },
   "type": "module",
   "scripts": {
-    "prebuild": "rimraf dist",
     "build": "tsc -p tsconfig.build.json",
     "postbuild": "tsc-alias -f -p tsconfig.build.json",
     "lint": "eslint . --cache",
@@ -32,9 +31,10 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@swc/core": "^1.15.24",
     "chokidar": "^5.0.0",
-    "commander": "^14.0.3"
+    "commander": "^14.0.3",
+    "oxc-resolver": "^11.19.1",
+    "oxc-transform": "^0.127.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^20.5.0",
@@ -42,7 +42,7 @@
     "@eslint/js": "^10.0.1",
     "@jest/globals": "^30.3.0",
     "@swc/jest": "^0.2.39",
-    "eslint": "^10.2.0",
+    "eslint": "^10.2.1",
     "eslint-plugin-jest": "^29.15.2",
     "eslint-plugin-prettier": "^5.5.5",
     "globals": "^17.5.0",
@@ -50,11 +50,10 @@
     "jest": "^30.3.0",
     "jest-environment-node": "^30.3.0",
     "lint-staged": "^16.4.0",
-    "prettier": "^3.8.2",
-    "rimraf": "^6.1.3",
+    "prettier": "^3.8.3",
     "tsc-alias": "^1.8.16",
-    "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.1"
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.0"
   },
   "engines": {
     "node": "^20.9.0 || ^22.11.0 || ^24.11.0"

package/dist/parse.js

@@ -1,435 +0,0 @@
-/**
- * JSON5 parse — zero dependencies, ESM + TypeScript
- *
- * Suporta toda a spec JSON5:
- *  - Chaves sem aspas (identificadores ES5/Unicode)
- *  - Strings single ou double quoted com escapes e line continuation
- *  - Comentários // e /* ... * /
- *  - Trailing commas em objetos e arrays
- *  - Números: hex, Infinity, NaN, +/- leading/trailing decimal
- *  - Reviver opcional (mesmo comportamento do JSON.parse nativo)
- */
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-function err(ctx, msg) {
-    throw new SyntaxError(`JSON5: ${msg} at ${ctx.line}:${ctx.col}`);
-}
-function current(ctx) {
-    return ctx.src[ctx.pos] ?? '';
-}
-function peek(ctx, offset = 1) {
-    return ctx.src[ctx.pos + offset] ?? '';
-}
-function advance(ctx) {
-    const ch = ctx.src[ctx.pos++] ?? '';
-    if (ch === '\n') {
-        ctx.line++;
-        ctx.col = 1;
-    }
-    else {
-        ctx.col++;
-    }
-    return ch;
-}
-function startsWith(ctx, s) {
-    return ctx.src.startsWith(s, ctx.pos);
-}
-function consume(ctx, s) {
-    ctx.pos += s.length;
-    ctx.col += s.length;
-}
-// ─── Whitespace + Comments ────────────────────────────────────────────────────
-const WHITESPACE = new Set([
-    ' ',
-    '\t',
-    '\r',
-    '\n',
-    '\u00A0',
-    '\u2028',
-    '\u2029',
-    '\uFEFF'
-]);
-function skipWhitespaceAndComments(ctx) {
-    while (ctx.pos < ctx.src.length) {
-        const ch = current(ctx);
-        if (WHITESPACE.has(ch)) {
-            advance(ctx);
-            continue;
-        }
-        // Comentário de linha: //
-        if (ch === '/' && peek(ctx, 1) === '/') {
-            advance(ctx);
-            advance(ctx);
-            while (ctx.pos < ctx.src.length &&
-                current(ctx) !== '\n' &&
-                current(ctx) !== '\r' &&
-                current(ctx) !== '\u2028' &&
-                current(ctx) !== '\u2029')
-                advance(ctx);
-            continue;
-        }
-        // Comentário de bloco: /* ... */
-        if (ch === '/' && peek(ctx, 1) === '*') {
-            advance(ctx);
-            advance(ctx);
-            while (ctx.pos < ctx.src.length) {
-                if (current(ctx) === '*' && peek(ctx, 1) === '/') {
-                    advance(ctx);
-                    advance(ctx);
-                    break;
-                }
-                advance(ctx);
-            }
-            continue;
-        }
-        break;
-    }
-}
-// ─── String ───────────────────────────────────────────────────────────────────
-function parseString(ctx) {
-    const quote = advance(ctx); // ' ou "
-    let result = '';
-    while (ctx.pos < ctx.src.length) {
-        const ch = current(ctx);
-        if (ch === quote) {
-            advance(ctx);
-            return result;
-        }
-        if (ch === '\\') {
-            advance(ctx);
-            const esc = advance(ctx);
-            switch (esc) {
-                case '"':
-                    result += '"';
-                    break;
-                case "'":
-                    result += "'";
-                    break;
-                case '\\':
-                    result += '\\';
-                    break;
-                case '/':
-                    result += '/';
-                    break;
-                case 'b':
-                    result += '\b';
-                    break;
-                case 'f':
-                    result += '\f';
-                    break;
-                case 'n':
-                    result += '\n';
-                    break;
-                case 'r':
-                    result += '\r';
-                    break;
-                case 't':
-                    result += '\t';
-                    break;
-                case 'v':
-                    result += '\v';
-                    break;
-                case '0':
-                    if (/[0-9]/.test(current(ctx)))
-                        err(ctx, 'Octal escapes are not allowed');
-                    result += '\0';
-                    break;
-                case 'x': {
-                    const hex = ctx.src.slice(ctx.pos, ctx.pos + 2);
-                    if (!/^[0-9a-fA-F]{2}$/.test(hex))
-                        err(ctx, 'Invalid hex escape sequence');
-                    result += String.fromCharCode(parseInt(hex, 16));
-                    ctx.pos += 2;
-                    ctx.col += 2;
-                    break;
-                }
-                case 'u': {
-                    if (current(ctx) === '{') {
-                        // \u{XXXXXX}
-                        advance(ctx);
-                        let hexStr = '';
-                        while (ctx.pos < ctx.src.length && current(ctx) !== '}')
-                            hexStr += advance(ctx);
-                        if (current(ctx) !== '}')
-                            err(ctx, 'Unterminated unicode escape');
-                        advance(ctx);
-                        const cp = parseInt(hexStr, 16);
-                        if (isNaN(cp) || cp > 0x10ffff)
-                            err(ctx, `Invalid unicode code point: ${hexStr}`);
-                        result += String.fromCodePoint(cp);
-                    }
-                    else {
-                        // \uXXXX
-                        const hex = ctx.src.slice(ctx.pos, ctx.pos + 4);
-                        if (!/^[0-9a-fA-F]{4}$/.test(hex))
-                            err(ctx, 'Invalid unicode escape sequence');
-                        result += String.fromCharCode(parseInt(hex, 16));
-                        ctx.pos += 4;
-                        ctx.col += 4;
-                    }
-                    break;
-                }
-                // Line continuation
-                case '\n':
-                case '\u2028':
-                case '\u2029':
-                    break;
-                case '\r':
-                    if (current(ctx) === '\n')
-                        advance(ctx);
-                    break;
-                default:
-                    result += esc;
-            }
-            continue;
-        }
-        if (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029') {
-            err(ctx, 'Unterminated string literal');
-        }
-        result += advance(ctx);
-    }
-    err(ctx, 'Unterminated string literal');
-}
-// ─── Identifier (chave sem aspas) ─────────────────────────────────────────────
-const IDENT_START = /[\p{L}\p{Nl}$_]/u;
-const IDENT_PART = /[\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}$_\u200C\u200D]/u;
-function isIdentStart(ch) {
-    return IDENT_START.test(ch);
-}
-function isIdentPart(ch) {
-    return IDENT_PART.test(ch);
-}
-function parseIdentifier(ctx) {
-    const first = current(ctx);
-    if (!isIdentStart(first))
-        err(ctx, `Unexpected character: ${JSON.stringify(first)}`);
-    let name = advance(ctx);
-    while (ctx.pos < ctx.src.length && isIdentPart(current(ctx))) {
-        name += advance(ctx);
-    }
-    return name;
-}
-// ─── Number ───────────────────────────────────────────────────────────────────
-function parseNumber(ctx) {
-    let numStr = '';
-    // Sinal opcional
-    if (current(ctx) === '+' || current(ctx) === '-') {
-        numStr += advance(ctx);
-    }
-    // Infinity
-    if (startsWith(ctx, 'Infinity')) {
-        consume(ctx, 'Infinity');
-        return numStr === '-' ? -Infinity : Infinity;
-    }
-    // NaN
-    if (startsWith(ctx, 'NaN')) {
-        consume(ctx, 'NaN');
-        return NaN;
-    }
-    // Hexadecimal: 0x / 0X
-    if (current(ctx) === '0' && (peek(ctx, 1) === 'x' || peek(ctx, 1) === 'X')) {
-        const sign = numStr; // pode ser '-' ou ''
-        numStr += advance(ctx); // '0'
-        numStr += advance(ctx); // 'x'
-        if (!/[0-9a-fA-F]/.test(current(ctx)))
-            err(ctx, 'Invalid hexadecimal number');
-        while (ctx.pos < ctx.src.length && /[0-9a-fA-F_]/.test(current(ctx))) {
-            const ch = advance(ctx);
-            if (ch !== '_')
-                numStr += ch;
-        }
-        const abs = parseInt(numStr, 16); // parseInt ignora o prefixo 0x corretamente
-        return sign === '-' ? -abs : abs;
-    }
-    // Parte inteira
-    while (ctx.pos < ctx.src.length && /[0-9_]/.test(current(ctx))) {
-        const ch = advance(ctx);
-        if (ch !== '_')
-            numStr += ch;
-    }
-    // Parte decimal
-    if (ctx.pos < ctx.src.length && current(ctx) === '.') {
-        numStr += advance(ctx);
-        while (ctx.pos < ctx.src.length && /[0-9_]/.test(current(ctx))) {
-            const ch = advance(ctx);
-            if (ch !== '_')
-                numStr += ch;
-        }
-    }
-    // Expoente
-    if (ctx.pos < ctx.src.length &&
-        (current(ctx) === 'e' || current(ctx) === 'E')) {
-        numStr += advance(ctx);
-        if (current(ctx) === '+' || current(ctx) === '-')
-            numStr += advance(ctx);
-        while (ctx.pos < ctx.src.length && /[0-9_]/.test(current(ctx))) {
-            const ch = advance(ctx);
-            if (ch !== '_')
-                numStr += ch;
-        }
-    }
-    const n = Number(numStr);
-    if (isNaN(n))
-        err(ctx, `Invalid number: ${numStr}`);
-    return n;
-}
-// ─── Value ────────────────────────────────────────────────────────────────────
-function parseValue(ctx) {
-    skipWhitespaceAndComments(ctx);
-    if (ctx.pos >= ctx.src.length)
-        err(ctx, 'Unexpected end of input');
-    const ch = current(ctx);
-    if (ch === '"' || ch === "'")
-        return parseString(ctx);
-    if (ch === '{')
-        return parseObject(ctx);
-    if (ch === '[')
-        return parseArray(ctx);
-    if (startsWith(ctx, 'true')) {
-        consume(ctx, 'true');
-        return true;
-    }
-    if (startsWith(ctx, 'false')) {
-        consume(ctx, 'false');
-        return false;
-    }
-    if (startsWith(ctx, 'null')) {
-        consume(ctx, 'null');
-        return null;
-    }
-    if (ch === '+' ||
-        ch === '-' ||
-        ch === '.' ||
-        (ch >= '0' && ch <= '9') ||
-        startsWith(ctx, 'Infinity') ||
-        startsWith(ctx, 'NaN'))
-        return parseNumber(ctx);
-    err(ctx, `Unexpected token: ${JSON.stringify(ch)}`);
-}
-// ─── Object ───────────────────────────────────────────────────────────────────
-function parseObject(ctx) {
-    advance(ctx); // {
-    const obj = {};
-    skipWhitespaceAndComments(ctx);
-    if (current(ctx) === '}') {
-        advance(ctx);
-        return obj;
-    }
-    while (ctx.pos < ctx.src.length) {
-        skipWhitespaceAndComments(ctx);
-        if (ctx.pos >= ctx.src.length)
-            err(ctx, 'Unterminated object');
-        // Trailing comma
-        if (current(ctx) === '}') {
-            advance(ctx);
-            return obj;
-        }
-        // Chave: string ou identifier
-        const ch = current(ctx);
-        const key = ch === '"' || ch === "'" ? parseString(ctx) : parseIdentifier(ctx);
-        skipWhitespaceAndComments(ctx);
-        if (current(ctx) !== ':')
-            err(ctx, `Expected ':' after key ${JSON.stringify(key)}`);
-        advance(ctx); // :
-        const entry = [key, parseValue(ctx)];
-        obj[entry[0]] = entry[1];
-        skipWhitespaceAndComments(ctx);
-        if (current(ctx) === ',') {
-            advance(ctx);
-            continue;
-        }
-        if (current(ctx) === '}') {
-            advance(ctx);
-            return obj;
-        }
-        err(ctx, 'Expected "," or "}" in object');
-    }
-    err(ctx, 'Unterminated object');
-}
-// ─── Array ────────────────────────────────────────────────────────────────────
-function parseArray(ctx) {
-    advance(ctx); // [
-    const arr = [];
-    skipWhitespaceAndComments(ctx);
-    if (current(ctx) === ']') {
-        advance(ctx);
-        return arr;
-    }
-    while (ctx.pos < ctx.src.length) {
-        skipWhitespaceAndComments(ctx);
-        if (ctx.pos >= ctx.src.length)
-            err(ctx, 'Unterminated array');
-        // Trailing comma
-        if (current(ctx) === ']') {
-            advance(ctx);
-            return arr;
-        }
-        arr.push(parseValue(ctx));
-        skipWhitespaceAndComments(ctx);
-        if (current(ctx) === ',') {
-            advance(ctx);
-            continue;
-        }
-        if (current(ctx) === ']') {
-            advance(ctx);
-            return arr;
-        }
-        err(ctx, 'Expected "," or "]" in array');
-    }
-    err(ctx, 'Unterminated array');
-}
-function applyReviver(reviver, holder, key) {
-    const val = holder[key];
-    if (val !== null && typeof val === 'object') {
-        const obj = val;
-        for (const k of Object.keys(obj)) {
-            const newVal = applyReviver(reviver, obj, k);
-            if (newVal === undefined)
-                delete obj[k];
-            else
-                obj[k] = newVal;
-        }
-    }
-    return reviver.call(holder, key, val);
-}
-// ─── API pública ──────────────────────────────────────────────────────────────
-/**
- * Faz o parse de uma string JSON5 e retorna o valor JavaScript correspondente.
- *
- * @param source  - String JSON5 a ser parseada.
- * @param reviver - Função opcional chamada para cada par chave/valor (igual ao `JSON.parse`).
- * @returns O valor JavaScript resultante tipado como `T`.
- *
- * @throws {SyntaxError} Se a string não for JSON5 válido.
- *
- * @example
- * ```ts
- * // Sem generic — retorna Json5Value
- * const raw = parse(`{ host: 'localhost' }`)
- *
- * // Com generic — cast para o tipo desejado
- * interface TsConfig {
- *   compilerOptions: {
- *     paths: Record<string, string[]>
- *     baseUrl: string
- *   }
- * }
- * const { compilerOptions: { paths, baseUrl } } = parse<TsConfig>(data)
- * ```
- */
-export function parse(source, reviver) {
-    const ctx = {
-        src: String(source),
-        pos: 0,
-        line: 1,
-        col: 1
-    };
-    const result = parseValue(ctx);
-    skipWhitespaceAndComments(ctx);
-    if (ctx.pos < ctx.src.length) {
-        err(ctx, `Unexpected token after value: ${JSON.stringify(current(ctx))}`);
-    }
-    if (typeof reviver === 'function') {
-        return applyReviver(reviver, { '': result }, '');
-    }
-    return result;
-}