redscript-mc 1.2.30 → 2.1.0

package/dist/src/cli.js

@@ -0,0 +1,474 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * RedScript CLI
+ *
+ * Usage:
+ *   redscript compile <file> [-o <out>] [--namespace <ns>]
+ *   redscript check <file>
+ *   redscript repl
+ *   redscript version
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const diagnostics_1 = require("./diagnostics");
+const mc_version_1 = require("./types/mc-version");
+const repl_1 = require("./repl");
+const metadata_1 = require("./builtins/metadata");
+const index_2 = require("./cache/index");
+const deps_1 = require("./cache/deps");
+const incremental_1 = require("./cache/incremental");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const child_process_1 = require("child_process");
+// Parse command line arguments
+const args = process.argv.slice(2);
+function printUsage() {
+    console.log(`
+RedScript Compiler v2
+
+Usage:
+  redscript compile <file> [-o <out>] [--namespace <ns>]
+  redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
+  redscript check <file>
+  redscript fmt <file.mcrs> [file2.mcrs ...]
+  redscript generate-dts [-o <file>]
+  redscript repl
+  redscript version
+
+Commands:
+  compile       Compile a RedScript file to a Minecraft datapack
+  watch         Watch a directory for .mcrs file changes, recompile, and hot reload
+  check         Check a RedScript file for errors without generating output
+  fmt           Auto-format RedScript source files
+  generate-dts  Generate builtin function declaration file (builtins.d.mcrs)
+  repl          Start an interactive RedScript REPL
+  version       Print the RedScript version
+  upgrade       Upgrade to the latest version (npm install -g redscript-mc@latest)
+
+Options:
+  -o, --output <path>    Output directory or file path
+  --namespace <ns>       Datapack namespace (default: derived from filename)
+  --hot-reload <url>     After each successful compile, POST to <url>/reload
+                         (use with redscript-testharness; e.g. http://localhost:25561)
+  --source-map           Generate .sourcemap.json files alongside .mcfunction output
+  --mc-version <ver>     Target Minecraft version (default: 1.21). Affects codegen features.
+                         e.g. --mc-version 1.20.2, --mc-version 1.19
+  --lenient              Treat type errors as warnings instead of blocking compilation
+  -h, --help             Show this help message
+`);
+}
+function getLocalVersion() {
+    const packagePath = path.join(__dirname, '..', 'package.json');
+    try {
+        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function printVersion() {
+    console.log(`RedScript v${getLocalVersion()}`);
+}
+/** Fetch latest version from npm registry (non-blocking, best-effort). */
+function fetchLatestVersion() {
+    return new Promise(resolve => {
+        const req = https.get('https://registry.npmjs.org/redscript-mc/latest', { timeout: 3000 }, res => {
+            let data = '';
+            res.on('data', chunk => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.version ?? null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+}
+/** Compare semver strings. Returns true if b > a. */
+function isNewer(current, latest) {
+    const parse = (v) => v.replace(/^v/, '').split('.').map(Number);
+    const [ca, cb, cc] = parse(current);
+    const [la, lb, lc] = parse(latest);
+    if (la !== ca)
+        return la > ca;
+    if (lb !== cb)
+        return lb > cb;
+    return lc > cc;
+}
+/**
+ * Check for a newer version and print a notice if one exists.
+ * Runs in background — does NOT block normal CLI operation.
+ */
+async function checkForUpdates(silent = false) {
+    const current = getLocalVersion();
+    const latest = await fetchLatestVersion();
+    if (latest && isNewer(current, latest)) {
+        console.log(`\n💡 New version available: v${current} → v${latest}`);
+        console.log(`   Run: redscript upgrade\n`);
+    }
+    else if (!silent && latest) {
+        // Only print when explicitly running 'version' or 'upgrade'
+        // No output for normal commands — keep startup noise-free
+    }
+}
+/** Run npm install -g to upgrade to latest. */
+function upgradeCommand() {
+    const current = getLocalVersion();
+    console.log(`Current version: v${current}`);
+    console.log('Checking latest version...');
+    fetchLatestVersion().then(latest => {
+        if (!latest) {
+            console.error('Could not fetch latest version from npm.');
+            process.exit(1);
+        }
+        if (!isNewer(current, latest)) {
+            console.log(`✅ Already up to date (v${current})`);
+            return;
+        }
+        console.log(`Upgrading v${current} → v${latest}...`);
+        try {
+            (0, child_process_1.execSync)('npm install -g redscript-mc@latest', { stdio: 'inherit' });
+            console.log(`✅ Upgraded to v${latest}`);
+        }
+        catch {
+            console.error('Upgrade failed. Try manually: npm install -g redscript-mc@latest');
+            process.exit(1);
+        }
+    });
+}
+function parseArgs(args) {
+    const result = {};
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === '-h' || arg === '--help') {
+            result.help = true;
+            i++;
+        }
+        else if (arg === '-o' || arg === '--output') {
+            result.output = args[++i];
+            i++;
+        }
+        else if (arg === '--namespace') {
+            result.namespace = args[++i];
+            i++;
+        }
+        else if (arg === '--hot-reload') {
+            result.hotReload = args[++i];
+            i++;
+        }
+        else if (arg === '--source-map') {
+            result.sourceMap = true;
+            i++;
+        }
+        else if (arg === '--mc-version') {
+            result.mcVersionStr = args[++i];
+            i++;
+        }
+        else if (arg === '--lenient') {
+            result.lenient = true;
+            i++;
+        }
+        else if (!result.command) {
+            result.command = arg;
+            i++;
+        }
+        else if (!result.file) {
+            result.file = arg;
+            i++;
+        }
+        else {
+            i++;
+        }
+    }
+    return result;
+}
+function deriveNamespace(filePath) {
+    const basename = path.basename(filePath, path.extname(filePath));
+    // Convert to valid identifier: lowercase, replace non-alphanumeric with underscore
+    return basename.toLowerCase().replace(/[^a-z0-9]/g, '_');
+}
+function compileCommand(file, output, namespace, sourceMap = false, mcVersionStr, lenient = false) {
+    // Read source file
+    if (!fs.existsSync(file)) {
+        console.error(`Error: File not found: ${file}`);
+        process.exit(1);
+    }
+    let mcVersion = mc_version_1.DEFAULT_MC_VERSION;
+    if (mcVersionStr) {
+        try {
+            mcVersion = (0, mc_version_1.parseMcVersion)(mcVersionStr);
+        }
+        catch (e) {
+            console.error(`Error: ${e.message}`);
+            process.exit(1);
+        }
+    }
+    const source = fs.readFileSync(file, 'utf-8');
+    try {
+        const result = (0, index_1.compile)(source, { namespace, filePath: file, generateSourceMap: sourceMap, mcVersion, lenient });
+        for (const w of result.warnings) {
+            console.error(`Warning: ${w}`);
+        }
+        // Create output directory
+        fs.mkdirSync(output, { recursive: true });
+        // Write all files
+        for (const dataFile of result.files) {
+            const filePath = path.join(output, dataFile.path);
+            const dir = path.dirname(filePath);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(filePath, dataFile.content);
+        }
+        console.log(`✓ Compiled ${file} to ${output}/`);
+        console.log(`  Namespace: ${namespace}`);
+        console.log(`  Files: ${result.files.length}`);
+    }
+    catch (err) {
+        console.error((0, diagnostics_1.formatError)(err, source, file));
+        process.exit(1);
+    }
+}
+function checkCommand(file, namespace) {
+    // Read source file
+    if (!fs.existsSync(file)) {
+        console.error(`Error: File not found: ${file}`);
+        process.exit(1);
+    }
+    const source = fs.readFileSync(file, 'utf-8');
+    const ns = namespace ?? deriveNamespace(file);
+    const result = (0, index_1.checkWithWarnings)(source, ns, file);
+    for (const w of result.warnings) {
+        console.error(`Warning: ${w}`);
+    }
+    if (result.error) {
+        console.error((0, diagnostics_1.formatError)(result.error, source, file));
+        process.exit(1);
+    }
+    console.log(`✓ No errors found`);
+}
+async function hotReload(url) {
+    try {
+        const res = await fetch(`${url}/reload`, { method: 'POST' });
+        if (res.ok) {
+            console.log(`🔄 Hot reload sent → ${url}`);
+        }
+        else {
+            console.warn(`⚠  Hot reload failed: HTTP ${res.status}`);
+        }
+    }
+    catch (e) {
+        console.warn(`⚠  Hot reload failed (is the server running?): ${e.message}`);
+    }
+}
+function watchCommand(dir, output, namespace, hotReloadUrl) {
+    // Check if directory exists
+    if (!fs.existsSync(dir)) {
+        console.error(`Error: Directory not found: ${dir}`);
+        process.exit(1);
+    }
+    const stat = fs.statSync(dir);
+    if (!stat.isDirectory()) {
+        console.error(`Error: ${dir} is not a directory`);
+        process.exit(1);
+    }
+    console.log(`👁  Watching ${dir} for .mcrs file changes...`);
+    console.log(`   Output: ${output}`);
+    if (hotReloadUrl)
+        console.log(`   Hot reload: ${hotReloadUrl}`);
+    console.log(`   Incremental compilation enabled`);
+    console.log(`   Press Ctrl+C to stop\n`);
+    // Set up incremental compilation infrastructure
+    const cacheDir = path.join(dir, '.redscript-cache');
+    const cache = new index_2.FileCache(cacheDir);
+    cache.load();
+    const depGraph = new deps_1.DependencyGraph();
+    // Debounce timer
+    let debounceTimer = null;
+    // Compile all .mcrs files in directory (incrementally)
+    async function compileAllIncremental() {
+        const files = findRsFiles(dir);
+        if (files.length === 0) {
+            console.log(`⚠  No .mcrs files found in ${dir}`);
+            return;
+        }
+        const incResult = (0, incremental_1.compileIncremental)(files, cache, depGraph, {
+            namespace,
+            output,
+        });
+        const timestamp = new Date().toLocaleTimeString();
+        // Print warnings from recompiled files
+        for (const [file, compileResult] of incResult.results) {
+            for (const w of compileResult.warnings) {
+                console.error(`Warning: ${w}`);
+            }
+            console.log(`✓ [${timestamp}] Compiled ${path.relative(dir, file)} (${compileResult.files.length} files)`);
+        }
+        if (incResult.cached > 0) {
+            console.log(`  [${timestamp}] ${incResult.cached} file(s) unchanged (cached)`);
+        }
+        // Print errors
+        for (const [file, errMsg] of incResult.errors) {
+            console.error(`✗ [${timestamp}] ${path.relative(dir, file)}: ${errMsg}`);
+        }
+        // Persist cache
+        cache.save();
+        if (incResult.errors.size === 0 && hotReloadUrl)
+            await hotReload(hotReloadUrl);
+        console.log('');
+    }
+    // Find all .mcrs files recursively
+    function findRsFiles(directory) {
+        const results = [];
+        const entries = fs.readdirSync(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(directory, entry.name);
+            if (entry.isDirectory() && entry.name !== '.redscript-cache') {
+                results.push(...findRsFiles(fullPath));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
+                results.push(fullPath);
+            }
+        }
+        return results;
+    }
+    // Initial compile
+    void compileAllIncremental();
+    // Watch for changes
+    fs.watch(dir, { recursive: true }, (eventType, filename) => {
+        if (filename && filename.endsWith('.mcrs')) {
+            // Debounce rapid changes
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
+            debounceTimer = setTimeout(() => {
+                console.log(`📝 Change detected: ${filename}`);
+                void compileAllIncremental();
+            }, 100);
+        }
+    });
+}
+// Main
+const parsed = parseArgs(args);
+async function main() {
+    if (parsed.help || !parsed.command) {
+        printUsage();
+        process.exit(parsed.help ? 0 : 1);
+    }
+    // Background update check — non-blocking, only shows notice if newer version exists
+    // Skip for repl/upgrade/version to avoid double-printing
+    const noCheckCmds = new Set(['upgrade', 'update', 'version', 'repl']);
+    if (!noCheckCmds.has(parsed.command ?? '')) {
+        checkForUpdates().catch(() => { });
+    }
+    switch (parsed.command) {
+        case 'compile':
+            if (!parsed.file) {
+                console.error('Error: No input file specified');
+                printUsage();
+                process.exit(1);
+            }
+            {
+                const namespace = parsed.namespace ?? deriveNamespace(parsed.file);
+                const output = parsed.output ?? './dist';
+                compileCommand(parsed.file, output, namespace, parsed.sourceMap, parsed.mcVersionStr, parsed.lenient);
+            }
+            break;
+        case 'watch':
+            if (!parsed.file) {
+                console.error('Error: No directory specified');
+                printUsage();
+                process.exit(1);
+            }
+            watchCommand(parsed.file, parsed.output ?? './dist', parsed.namespace, parsed.hotReload);
+            break;
+        case 'check':
+            if (!parsed.file) {
+                console.error('Error: No input file specified');
+                printUsage();
+                process.exit(1);
+            }
+            checkCommand(parsed.file, parsed.namespace);
+            break;
+        case 'fmt':
+        case 'format': {
+            const files = args.filter(a => a.endsWith('.mcrs'));
+            if (files.length === 0) {
+                console.error('Usage: redscript fmt <file.mcrs> [file2.mcrs ...]');
+                process.exit(1);
+            }
+            const { format } = require('./formatter');
+            for (const file of files) {
+                const content = fs.readFileSync(file, 'utf8');
+                const formatted = format(content);
+                fs.writeFileSync(file, formatted);
+                console.log(`Formatted: ${file}`);
+            }
+            break;
+        }
+        case 'generate-dts': {
+            const output = parsed.output ?? 'builtins.d.mcrs';
+            const dtsContent = (0, metadata_1.generateDts)();
+            fs.writeFileSync(output, dtsContent, 'utf-8');
+            console.log(`Generated ${output}`);
+            break;
+        }
+        case 'repl':
+            await (0, repl_1.startRepl)(parsed.namespace ?? 'repl');
+            break;
+        case 'version':
+            printVersion();
+            await checkForUpdates();
+            break;
+        case 'upgrade':
+        case 'update':
+            upgradeCommand();
+            break;
+        default:
+            console.error(`Error: Unknown command '${parsed.command}'`);
+            printUsage();
+            process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=cli.js.map

package/dist/src/compile.d.ts

@@ -0,0 +1,37 @@
+/**
+ * RedScript Compile API
+ *
+ * Preprocessing utilities and v2 compile re-export.
+ */
+export { compile, CompileOptions, CompileResult } from './emit/compile';
+export type { DatapackFile } from './emit/index';
+export interface SourceRange {
+    startLine: number;
+    endLine: number;
+    filePath: string;
+}
+export interface PreprocessedSource {
+    source: string;
+    ranges: SourceRange[];
+    /** Imported files that declared `module library;` — parsed separately
+     *  in library mode so their functions are DCE-eligible.  Never concatenated
+     *  into `source`. */
+    libraryImports?: Array<{
+        source: string;
+        filePath: string;
+    }>;
+}
+/**
+ * Resolve a combined-source line number back to the original file and line.
+ * Returns { filePath, line } if a mapping is found, otherwise returns the input unchanged.
+ */
+export declare function resolveSourceLine(combinedLine: number, ranges: SourceRange[], fallbackFile?: string): {
+    filePath?: string;
+    line: number;
+};
+interface PreprocessOptions {
+    filePath?: string;
+    seen?: Set<string>;
+}
+export declare function preprocessSourceWithMetadata(source: string, options?: PreprocessOptions): PreprocessedSource;
+export declare function preprocessSource(source: string, options?: PreprocessOptions): string;

package/dist/src/compile.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * RedScript Compile API
+ *
+ * Preprocessing utilities and v2 compile re-export.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+exports.resolveSourceLine = resolveSourceLine;
+exports.preprocessSourceWithMetadata = preprocessSourceWithMetadata;
+exports.preprocessSource = preprocessSource;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const diagnostics_1 = require("./diagnostics");
+// ---------------------------------------------------------------------------
+// Re-export v2 compile
+// ---------------------------------------------------------------------------
+var compile_1 = require("./emit/compile");
+Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compile_1.compile; } });
+/**
+ * Resolve a combined-source line number back to the original file and line.
+ * Returns { filePath, line } if a mapping is found, otherwise returns the input unchanged.
+ */
+function resolveSourceLine(combinedLine, ranges, fallbackFile) {
+    for (const range of ranges) {
+        if (combinedLine >= range.startLine && combinedLine <= range.endLine) {
+            const localLine = combinedLine - range.startLine + 1;
+            return { filePath: range.filePath, line: localLine };
+        }
+    }
+    return { filePath: fallbackFile, line: combinedLine };
+}
+const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/;
+/** Returns true if the source file declares `module library;` at its top
+ *  (before any non-comment/non-blank lines). */
+function isLibrarySource(source) {
+    for (const line of source.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('//'))
+            continue;
+        return /^module\s+library\s*;/.test(trimmed);
+    }
+    return false;
+}
+function countLines(source) {
+    return source === '' ? 0 : source.split('\n').length;
+}
+function offsetRanges(ranges, lineOffset) {
+    return ranges.map(range => ({
+        startLine: range.startLine + lineOffset,
+        endLine: range.endLine + lineOffset,
+        filePath: range.filePath,
+    }));
+}
+function preprocessSourceWithMetadata(source, options = {}) {
+    const { filePath } = options;
+    const seen = options.seen ?? new Set();
+    if (filePath) {
+        seen.add(path.resolve(filePath));
+    }
+    const lines = source.split('\n');
+    const imports = [];
+    /** Library imports: `module library;` files routed here instead of concatenated. */
+    const libraryImports = [];
+    const bodyLines = [];
+    let parsingHeader = true;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        const match = line.match(IMPORT_RE);
+        if (parsingHeader && match) {
+            if (!filePath) {
+                throw new diagnostics_1.DiagnosticError('ParseError', 'Import statements require a file path', { line: i + 1, col: 1 }, lines);
+            }
+            const importPath = path.resolve(path.dirname(filePath), match[1]);
+            if (!seen.has(importPath)) {
+                seen.add(importPath);
+                let importedSource;
+                try {
+                    importedSource = fs.readFileSync(importPath, 'utf-8');
+                }
+                catch {
+                    throw new diagnostics_1.DiagnosticError('ParseError', `Cannot import '${match[1]}'`, { file: filePath, line: i + 1, col: 1 }, lines);
+                }
+                if (isLibrarySource(importedSource)) {
+                    // Library file: parse separately so its functions are DCE-eligible.
+                    // Also collect any transitive library imports inside it.
+                    const nested = preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen });
+                    libraryImports.push({ source: importedSource, filePath: importPath });
+                    // Propagate transitive library imports (e.g. math.mcrs imports vec.mcrs)
+                    if (nested.libraryImports)
+                        libraryImports.push(...nested.libraryImports);
+                }
+                else {
+                    imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }));
+                }
+            }
+            continue;
+        }
+        if (parsingHeader && (trimmed === '' || trimmed.startsWith('//'))) {
+            bodyLines.push(line);
+            continue;
+        }
+        parsingHeader = false;
+        bodyLines.push(line);
+    }
+    const body = bodyLines.join('\n');
+    const parts = [...imports.map(entry => entry.source), body].filter(Boolean);
+    const combined = parts.join('\n');
+    const ranges = [];
+    let lineOffset = 0;
+    for (const entry of imports) {
+        ranges.push(...offsetRanges(entry.ranges, lineOffset));
+        lineOffset += countLines(entry.source);
+    }
+    if (filePath && body) {
+        ranges.push({
+            startLine: lineOffset + 1,
+            endLine: lineOffset + countLines(body),
+            filePath: path.resolve(filePath),
+        });
+    }
+    return {
+        source: combined,
+        ranges,
+        libraryImports: libraryImports.length > 0 ? libraryImports : undefined,
+    };
+}
+function preprocessSource(source, options = {}) {
+    return preprocessSourceWithMetadata(source, options).source;
+}
+//# sourceMappingURL=compile.js.map

package/dist/{diagnostics → src/diagnostics}/index.d.ts

@@ -41,4 +41,4 @@ export declare class DiagnosticCollector {
  * e.g., "Expected ';' at line 5, col 12"
  */
 export declare function parseErrorMessage(kind: DiagnosticKind, rawMessage: string, sourceLines?: string[], filePath?: string): DiagnosticError;
-export declare function formatError(error: Error | DiagnosticError, source?: string): string;
+export declare function formatError(error: Error | DiagnosticError, source?: string, filePath?: string): string;