tsnite 0.2.1 → 0.2.3

package/dist/cache.js

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto';
-import { mkdir, rm } from 'node:fs/promises';
+import { mkdir, rm, stat } 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');
 }
@@ -11,9 +12,27 @@ 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`);
 }
@@ -27,6 +46,7 @@ export function isTSConfigPath(filePath) {
     return resolve(filePath) === getTSConfigPath();
 }
 export async function invalidateFileCaches(filePath) {
+    invalidateStatCache(filePath);
     clearResolveCache();
     if (isTSConfigPath(filePath)) {
         await clearTranspileCache();

package/dist/loader.js

@@ -1,25 +1,72 @@
-import { transform } from 'oxc-transform';
-import { ResolverFactory } from 'oxc-resolver';
+import { transformFile } from '@swc/core';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { readFile, stat, writeFile } from 'node:fs/promises';
-import { writeSync } from 'node:fs';
-import { relative } from 'node:path';
+import { extname, join, dirname } from 'node:path';
 import { createHash } from 'node:crypto';
-import { ensureTranspileCacheDir, getTranspileCacheFile, resolveCache } from './cache.js';
-import { gray, green, yellow } from './util.js';
+import { parse } from './parse.js';
+import { ensureTranspileCacheDir, existsWithCache, getTranspileCacheFile, resolveCache } from './cache.js';
+const tsconfigCache = { paths: null, baseUrl: null };
 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');
 }
@@ -75,11 +122,42 @@ 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) {
-    if (typeof ctx.parentURL !== 'string') {
+    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('/')) {
         return next(specifier, ctx);
     }
-    if (ctx.parentURL.startsWith('file://') === false) {
+    if (!isTypeScriptSpecifier(specifier)) {
         return next(specifier, ctx);
     }
     const cacheKey = `${ctx.parentURL}::${specifier}`;
@@ -95,10 +173,28 @@ export async function resolve(specifier, ctx, next) {
         };
     }
     const parentPath = fileURLToPath(ctx.parentURL);
-    try {
-        const result = await resolver.resolveFileAsync(parentPath, specifier);
-        if (result.path) {
-            const url = pathToFileURL(result.path).href;
+    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;
             resolveCache.set(cacheKey, url);
             return {
                 url,
@@ -107,10 +203,6 @@ export async function resolve(specifier, ctx, next) {
             };
         }
     }
-    catch {
-        resolveCache.set(cacheKey, null);
-        return next(specifier, ctx);
-    }
     resolveCache.set(cacheKey, null);
     return next(specifier, ctx);
 }
@@ -118,37 +210,54 @@ 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 cachedCode = await readCachedTranspile(filename, fileStats.mtimeMs, fileStats.size, TRANSPILE_CONFIG_HASH);
+    const configHash = hash(JSON.stringify({
+        baseUrl: baseUrl || process.cwd(),
+        paths: paths ?? {}
+    }));
+    const cachedCode = await readCachedTranspile(filename, fileStats.mtimeMs, fileStats.size, configHash);
     if (cachedCode !== null) {
         return { format: 'module', source: cachedCode, shortCircuit: true };
     }
-    const source = await readFile(filename, 'utf8');
-    const transpileStart = Date.now();
-    const { code } = await transform(filename, source, {
-        jsx: {
-            runtime: 'automatic',
-            development: 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 ?? {}
         },
-        sourcemap: true,
-        sourceType: 'module',
-        target: 'es2024',
-        decorator: {
-            emitDecoratorMetadata: true,
-            legacy: true
-        }
+        module: {
+            type: 'es6',
+            strict: true,
+            outFileExtension: 'ts',
+            resolveFully: true
+        },
+        sourceMaps: 'inline'
     });
-    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: TRANSPILE_CONFIG_HASH
+        configHash
     });
     return { format: 'module', source: code, shortCircuit: true };
 }

package/dist/parse.js

@@ -0,0 +1,435 @@
+/**
+ * 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;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tsnite",
   "description": "TypeScript at full throttle—fast, safe, unstoppable. 🚀",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "keywords": [
     "cli",
     "esm",
@@ -31,10 +31,9 @@
     "prepare": "husky"
   },
   "dependencies": {
+    "@swc/core": "^1.15.30",
     "chokidar": "^5.0.0",
-    "commander": "^14.0.3",
-    "oxc-resolver": "^11.19.1",
-    "oxc-transform": "^0.127.0"
+    "commander": "^14.0.3"
   },
   "devDependencies": {
     "@commitlint/cli": "^20.5.0",
@@ -51,6 +50,7 @@
     "jest-environment-node": "^30.3.0",
     "lint-staged": "^16.4.0",
     "prettier": "^3.8.3",
+    "rimraf": "^6.1.3",
     "tsc-alias": "^1.8.16",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.59.0"