tsnite 0.2.0 → 0.2.2

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/loader.js

@@ -1,75 +1,25 @@
 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 { writeSync } from 'node:fs';
-import { extname, join, dirname, relative } from 'node:path';
+import { relative } from 'node:path';
 import { createHash } from 'node:crypto';
-import { parse } from './parse.js';
-import { ensureTranspileCacheDir, existsWithCache, getTranspileCacheFile, resolveCache } from './cache.js';
+import { ensureTranspileCacheDir, getTranspileCacheFile, resolveCache } from './cache.js';
 import { gray, green, yellow } from './util.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:esnext|jsx:automatic|decorator:legacy|emitDecoratorMetadata:true|helpers:runtime');
+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');
 }
@@ -125,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}`;
@@ -176,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,
@@ -206,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);
 }
@@ -213,14 +118,9 @@ 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 };
     }
@@ -233,11 +133,8 @@ export async function load(url, ctx, next) {
         },
         sourcemap: true,
         sourceType: 'module',
-        target: 'es2024',
-        decorator: {
-            emitDecoratorMetadata: true,
-            legacy: true
-        }
+        target: 'esnext',
+        decorator: { legacy: true, emitDecoratorMetadata: true }
     });
     if (SHOULD_LOG_TRANSPILE) {
         const transpileTimeMs = Date.now() - transpileStart;
@@ -248,7 +145,7 @@ export async function load(url, ctx, next) {
         code,
         mtimeMs: fileStats.mtimeMs,
         size: fileStats.size,
-        configHash
+        configHash: TRANSPILE_CONFIG_HASH
     });
     return { format: 'module', source: code, shortCircuit: true };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tsnite",
   "description": "TypeScript at full throttle—fast, safe, unstoppable. 🚀",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "keywords": [
     "cli",
     "esm",
@@ -31,8 +31,10 @@
     "prepare": "husky"
   },
   "dependencies": {
+    "@oxc-project/runtime": "^0.127.0",
     "chokidar": "^5.0.0",
     "commander": "^14.0.3",
+    "oxc-resolver": "^11.19.1",
     "oxc-transform": "^0.127.0"
   },
   "devDependencies": {

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;
-}