redscript-mc 2.4.1 → 2.6.0

package/dist/runtime/index.js

@@ -1,1409 +0,0 @@
-"use strict";
-/**
- * MCRuntime - Minecraft Command Runtime Simulator
- *
- * A TypeScript interpreter that simulates the subset of MC commands that
- * RedScript generates, allowing behavioral testing without a real server.
- */
-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.MCRuntime = void 0;
-exports.parseRange = parseRange;
-exports.matchesRange = matchesRange;
-exports.parseSelector = parseSelector;
-const compile_1 = require("../compile");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-// ---------------------------------------------------------------------------
-// Selector & Range Parsing
-// ---------------------------------------------------------------------------
-function parseRange(s) {
-    if (s.includes('..')) {
-        const [left, right] = s.split('..');
-        return {
-            min: left === '' ? -Infinity : parseInt(left, 10),
-            max: right === '' ? Infinity : parseInt(right, 10),
-        };
-    }
-    const val = parseInt(s, 10);
-    return { min: val, max: val };
-}
-function matchesRange(value, range) {
-    return value >= range.min && value <= range.max;
-}
-function canonicalEntityType(entityType) {
-    return entityType.includes(':') ? entityType : `minecraft:${entityType}`;
-}
-function parseFilters(content) {
-    const filters = {
-        tag: [],
-        notTag: [],
-        type: [],
-        notType: [],
-    };
-    if (!content)
-        return filters;
-    // Handle scores={...} separately
-    let processed = content;
-    const scoresMatch = content.match(/scores=\{([^}]*)\}/);
-    if (scoresMatch) {
-        filters.scores = new Map();
-        const scoresPart = scoresMatch[1];
-        const scoreEntries = scoresPart.split(',');
-        for (const entry of scoreEntries) {
-            const [obj, range] = entry.split('=');
-            if (obj && range) {
-                filters.scores.set(obj.trim(), parseRange(range.trim()));
-            }
-        }
-        processed = content.replace(/,?scores=\{[^}]*\},?/, ',').replace(/^,|,$/g, '');
-    }
-    // Parse remaining filters
-    const parts = processed.split(',').filter(p => p.trim());
-    for (const part of parts) {
-        const [key, value] = part.split('=').map(s => s.trim());
-        if (key === 'tag') {
-            if (value.startsWith('!')) {
-                filters.notTag.push(value.slice(1));
-            }
-            else {
-                filters.tag.push(value);
-            }
-        }
-        else if (key === 'type') {
-            if (value.startsWith('!')) {
-                filters.notType.push(value.slice(1));
-            }
-            else {
-                filters.type.push(value);
-            }
-        }
-        else if (key === 'limit') {
-            filters.limit = parseInt(value, 10);
-        }
-    }
-    return filters;
-}
-function matchesFilters(entity, filters, objective = 'rs') {
-    // Check required tags
-    for (const tag of filters.tag || []) {
-        if (!entity.tags.has(tag))
-            return false;
-    }
-    // Check excluded tags
-    for (const notTag of filters.notTag || []) {
-        if (entity.tags.has(notTag))
-            return false;
-    }
-    // Check types
-    if ((filters.type?.length ?? 0) > 0) {
-        const entityType = canonicalEntityType(entity.type ?? 'minecraft:armor_stand');
-        const allowedTypes = filters.type.map(canonicalEntityType);
-        if (!allowedTypes.includes(entityType)) {
-            return false;
-        }
-    }
-    for (const notType of filters.notType || []) {
-        const entityType = canonicalEntityType(entity.type ?? 'minecraft:armor_stand');
-        if (canonicalEntityType(notType) === entityType) {
-            return false;
-        }
-    }
-    // Check scores
-    if (filters.scores) {
-        for (const [obj, range] of filters.scores) {
-            const score = entity.scores.get(obj) ?? 0;
-            if (!matchesRange(score, range))
-                return false;
-        }
-    }
-    return true;
-}
-function parseSelector(sel, entities, executor) {
-    // Handle @s
-    if (sel === '@s') {
-        return executor ? [executor] : [];
-    }
-    // Handle bare selectors
-    if (sel === '@e' || sel === '@a') {
-        return [...entities];
-    }
-    // Parse selector with brackets
-    const match = sel.match(/^(@[eaps])(?:\[(.*)\])?$/);
-    if (!match) {
-        return [];
-    }
-    const [, selectorType, bracketContent] = match;
-    // @s with filters
-    if (selectorType === '@s') {
-        if (!executor)
-            return [];
-        const filters = parseFilters(bracketContent || '');
-        if (matchesFilters(executor, filters)) {
-            return [executor];
-        }
-        return [];
-    }
-    // @e/@a with filters
-    const filters = parseFilters(bracketContent || '');
-    let result = entities.filter(e => matchesFilters(e, filters));
-    // Apply limit
-    if (filters.limit !== undefined) {
-        result = result.slice(0, filters.limit);
-    }
-    return result;
-}
-// ---------------------------------------------------------------------------
-// JSON Component Parsing
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// NBT Parsing
-// ---------------------------------------------------------------------------
-function parseNBT(nbt) {
-    // Simple NBT parser for Tags array
-    const result = {};
-    const tagsMatch = nbt.match(/Tags:\s*\[(.*?)\]/);
-    if (tagsMatch) {
-        const tagsStr = tagsMatch[1];
-        result.Tags = tagsStr
-            .split(',')
-            .map(s => s.trim().replace(/^["']|["']$/g, ''))
-            .filter(s => s.length > 0);
-    }
-    return result;
-}
-// ---------------------------------------------------------------------------
-// MCRuntime Class
-// ---------------------------------------------------------------------------
-class MCRuntime {
-    constructor(namespace) {
-        // Scoreboard state: objective → (player → score)
-        this.scoreboard = new Map();
-        // NBT storage: "namespace:path" → JSON value
-        this.storage = new Map();
-        // Entities in world
-        this.entities = [];
-        // Loaded functions: "ns:name" → lines of mcfunction
-        this.functions = new Map();
-        // Log of say/tellraw/title output
-        this.chatLog = [];
-        // Simple world state: "x,y,z" -> block id
-        this.world = new Map();
-        // Current weather
-        this.weather = 'clear';
-        // Current world time
-        this.worldTime = 0;
-        // Active potion effects by entity id
-        this.effects = new Map();
-        // XP values by player/entity id
-        this.xp = new Map();
-        // Tick counter
-        this.tickCount = 0;
-        // Entity ID counter
-        this.entityIdCounter = 0;
-        // Flag to stop function execution (for return)
-        this.shouldReturn = false;
-        // Current MC macro context: key → value (set by 'function ... with storage')
-        this.currentMacroContext = null;
-        this.namespace = namespace;
-        // Initialize default objective
-        this.scoreboard.set('rs', new Map());
-    }
-    // -------------------------------------------------------------------------
-    // Datapack Loading
-    // -------------------------------------------------------------------------
-    loadDatapack(dir) {
-        const functionsDir = path.join(dir, 'data', this.namespace, 'function');
-        if (!fs.existsSync(functionsDir))
-            return;
-        const loadFunctions = (base, prefix) => {
-            const entries = fs.readdirSync(base, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(base, entry.name);
-                if (entry.isDirectory()) {
-                    loadFunctions(fullPath, `${prefix}${entry.name}/`);
-                }
-                else if (entry.name.endsWith('.mcfunction')) {
-                    const fnName = `${prefix}${entry.name.replace('.mcfunction', '')}`;
-                    const content = fs.readFileSync(fullPath, 'utf-8');
-                    this.loadFunction(`${this.namespace}:${fnName}`, content.split('\n'));
-                }
-            }
-        };
-        loadFunctions(functionsDir, '');
-    }
-    loadFunction(name, lines) {
-        // Filter out comments and empty lines, but keep all commands
-        const cleaned = lines
-            .map(l => l.trim())
-            .filter(l => l && !l.startsWith('#'));
-        this.functions.set(name, cleaned);
-    }
-    // -------------------------------------------------------------------------
-    // Lifecycle Methods
-    // -------------------------------------------------------------------------
-    load() {
-        const loadFn = `${this.namespace}:__load`;
-        if (this.functions.has(loadFn)) {
-            this.execFunction(loadFn);
-        }
-    }
-    tick() {
-        this.tickCount++;
-        const tickFn = `${this.namespace}:__tick`;
-        if (this.functions.has(tickFn)) {
-            this.execFunction(tickFn);
-        }
-    }
-    ticks(n) {
-        for (let i = 0; i < n; i++) {
-            this.tick();
-        }
-    }
-    // -------------------------------------------------------------------------
-    // Function Execution
-    // -------------------------------------------------------------------------
-    execFunction(name, executor) {
-        const lines = this.functions.get(name);
-        if (!lines) {
-            // Try with namespace prefix
-            const prefixedName = name.includes(':') ? name : `${this.namespace}:${name}`;
-            const prefixedLines = this.functions.get(prefixedName);
-            if (!prefixedLines)
-                return;
-            this.execFunctionLines(prefixedLines, executor);
-            return;
-        }
-        this.execFunctionLines(lines, executor);
-    }
-    execFunctionLines(lines, executor) {
-        this.shouldReturn = false;
-        for (const line of lines) {
-            if (this.shouldReturn)
-                break;
-            this.execCommand(line, executor);
-        }
-    }
-    // -------------------------------------------------------------------------
-    // Command Execution
-    // -------------------------------------------------------------------------
-    execCommand(cmd, executor) {
-        cmd = cmd.trim();
-        if (!cmd || cmd.startsWith('#'))
-            return true;
-        // MC macro command: line starts with '$'.
-        // Expand $(key) placeholders from currentMacroContext, then execute.
-        if (cmd.startsWith('$')) {
-            const expanded = this.expandMacro(cmd.slice(1));
-            return this.execCommand(expanded, executor);
-        }
-        // Parse command
-        if (cmd.startsWith('scoreboard ')) {
-            return this.execScoreboard(cmd);
-        }
-        if (cmd.startsWith('execute ')) {
-            return this.execExecute(cmd, executor);
-        }
-        if (cmd.startsWith('function ')) {
-            return this.execFunctionCmd(cmd, executor);
-        }
-        if (cmd.startsWith('data ')) {
-            return this.execData(cmd);
-        }
-        if (cmd.startsWith('tag ')) {
-            return this.execTag(cmd, executor);
-        }
-        if (cmd.startsWith('say ')) {
-            return this.execSay(cmd, executor);
-        }
-        if (cmd.startsWith('tellraw ')) {
-            return this.execTellraw(cmd);
-        }
-        if (cmd.startsWith('title ')) {
-            return this.execTitle(cmd);
-        }
-        if (cmd.startsWith('setblock ')) {
-            return this.execSetblock(cmd);
-        }
-        if (cmd.startsWith('fill ')) {
-            return this.execFill(cmd);
-        }
-        if (cmd.startsWith('tp ')) {
-            return this.execTp(cmd, executor);
-        }
-        if (cmd.startsWith('weather ')) {
-            return this.execWeather(cmd);
-        }
-        if (cmd.startsWith('time ')) {
-            return this.execTime(cmd);
-        }
-        if (cmd.startsWith('kill ')) {
-            return this.execKill(cmd, executor);
-        }
-        if (cmd.startsWith('effect ')) {
-            return this.execEffect(cmd, executor);
-        }
-        if (cmd.startsWith('xp ')) {
-            return this.execXp(cmd, executor);
-        }
-        if (cmd.startsWith('summon ')) {
-            return this.execSummon(cmd);
-        }
-        if (cmd.startsWith('return ')) {
-            return this.execReturn(cmd, executor);
-        }
-        if (cmd === 'return') {
-            this.shouldReturn = true;
-            return true;
-        }
-        // Unknown command - succeed silently
-        return true;
-    }
-    // -------------------------------------------------------------------------
-    // Scoreboard Commands
-    // -------------------------------------------------------------------------
-    execScoreboard(cmd) {
-        const parts = cmd.split(/\s+/);
-        // scoreboard objectives add <name> <criteria>
-        if (parts[1] === 'objectives' && parts[2] === 'add') {
-            const name = parts[3];
-            if (!this.scoreboard.has(name)) {
-                this.scoreboard.set(name, new Map());
-            }
-            return true;
-        }
-        // scoreboard players ...
-        if (parts[1] === 'players') {
-            const action = parts[2];
-            const player = parts[3];
-            const objective = parts[4];
-            switch (action) {
-                case 'set': {
-                    const value = parseInt(parts[5], 10);
-                    this.setScore(player, objective, value);
-                    return true;
-                }
-                case 'add': {
-                    const delta = parseInt(parts[5], 10);
-                    this.addScore(player, objective, delta);
-                    return true;
-                }
-                case 'remove': {
-                    const delta = parseInt(parts[5], 10);
-                    this.addScore(player, objective, -delta);
-                    return true;
-                }
-                case 'get': {
-                    this.returnValue = this.getScore(player, objective);
-                    return true;
-                }
-                case 'reset': {
-                    const obj = this.scoreboard.get(objective);
-                    if (obj)
-                        obj.delete(player);
-                    return true;
-                }
-                case 'enable': {
-                    // No-op for trigger enabling
-                    return true;
-                }
-                case 'operation': {
-                    // scoreboard players operation <target> <targetObj> <op> <source> <sourceObj>
-                    const targetObj = objective;
-                    const op = parts[5];
-                    const source = parts[6];
-                    const sourceObj = parts[7];
-                    const targetVal = this.getScore(player, targetObj);
-                    const sourceVal = this.getScore(source, sourceObj);
-                    let result;
-                    switch (op) {
-                        case '=':
-                            result = sourceVal;
-                            break;
-                        case '+=':
-                            result = targetVal + sourceVal;
-                            break;
-                        case '-=':
-                            result = targetVal - sourceVal;
-                            break;
-                        case '*=':
-                            result = targetVal * sourceVal;
-                            break;
-                        case '/=':
-                            result = Math.trunc(targetVal / sourceVal);
-                            break;
-                        case '%=':
-                            result = targetVal % sourceVal; // Java modulo: sign follows dividend
-                            break;
-                        case '<':
-                            result = Math.min(targetVal, sourceVal);
-                            break;
-                        case '>':
-                            result = Math.max(targetVal, sourceVal);
-                            break;
-                        case '><':
-                            // Swap
-                            this.setScore(player, targetObj, sourceVal);
-                            this.setScore(source, sourceObj, targetVal);
-                            return true;
-                        default:
-                            return false;
-                    }
-                    this.setScore(player, targetObj, result);
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    // -------------------------------------------------------------------------
-    // Execute Commands
-    // -------------------------------------------------------------------------
-    execExecute(cmd, executor) {
-        // Remove 'execute ' prefix
-        let rest = cmd.slice(8);
-        // Track execute state
-        let currentExecutor = executor;
-        let condition = true;
-        let storeTarget = null;
-        while (rest.length > 0) {
-            rest = rest.trimStart();
-            // Handle 'run' - execute the final command
-            if (rest.startsWith('run ')) {
-                if (!condition)
-                    return false;
-                const innerCmd = rest.slice(4);
-                const result = this.execCommand(innerCmd, currentExecutor);
-                if (storeTarget) {
-                    const value = storeTarget.type === 'result'
-                        ? (this.returnValue ?? (result ? 1 : 0))
-                        : (result ? 1 : 0);
-                    if ('storagePath' in storeTarget) {
-                        this.setStorageField(storeTarget.storagePath, storeTarget.field, value);
-                    }
-                    else {
-                        this.setScore(storeTarget.player, storeTarget.objective, value);
-                    }
-                }
-                return result;
-            }
-            // Handle 'as <selector>'
-            if (rest.startsWith('as ')) {
-                rest = rest.slice(3);
-                const { selector, remaining } = this.parseNextSelector(rest);
-                rest = remaining;
-                const entities = parseSelector(selector, this.entities, currentExecutor);
-                if (entities.length === 0)
-                    return false;
-                // For multiple entities, execute as each
-                if (entities.length > 1) {
-                    let success = false;
-                    for (const entity of entities) {
-                        const result = this.execCommand('execute ' + rest, entity);
-                        success = success || result;
-                    }
-                    return success;
-                }
-                currentExecutor = entities[0];
-                continue;
-            }
-            // Handle 'at <selector>' - no-op for position, just continue
-            if (rest.startsWith('at ')) {
-                rest = rest.slice(3);
-                const { remaining } = this.parseNextSelector(rest);
-                rest = remaining;
-                continue;
-            }
-            // Handle 'if score <player> <obj> matches <range>'
-            if (rest.startsWith('if score ')) {
-                rest = rest.slice(9);
-                const scoreParts = rest.match(/^(\S+)\s+(\S+)\s+matches\s+(\S+)(.*)$/);
-                if (scoreParts) {
-                    const [, player, obj, rangeStr, remaining] = scoreParts;
-                    const range = parseRange(rangeStr);
-                    const score = this.getScore(player, obj);
-                    condition = condition && matchesRange(score, range);
-                    rest = remaining.trim();
-                    continue;
-                }
-                // if score <p1> <o1> <op> <p2> <o2>
-                const compareMatch = rest.match(/^(\S+)\s+(\S+)\s+([<>=]+)\s+(\S+)\s+(\S+)(.*)$/);
-                if (compareMatch) {
-                    const [, p1, o1, op, p2, o2, remaining] = compareMatch;
-                    const v1 = this.getScore(p1, o1);
-                    const v2 = this.getScore(p2, o2);
-                    let matches = false;
-                    switch (op) {
-                        case '=':
-                            matches = v1 === v2;
-                            break;
-                        case '<':
-                            matches = v1 < v2;
-                            break;
-                        case '<=':
-                            matches = v1 <= v2;
-                            break;
-                        case '>':
-                            matches = v1 > v2;
-                            break;
-                        case '>=':
-                            matches = v1 >= v2;
-                            break;
-                    }
-                    condition = condition && matches;
-                    rest = remaining.trim();
-                    continue;
-                }
-            }
-            // Handle 'unless score ...'
-            if (rest.startsWith('unless score ')) {
-                rest = rest.slice(13);
-                // unless score <player> <obj> matches <range>
-                const matchesParts = rest.match(/^(\S+)\s+(\S+)\s+matches\s+(\S+)(.*)$/);
-                if (matchesParts) {
-                    const [, player, obj, rangeStr, remaining] = matchesParts;
-                    const range = parseRange(rangeStr);
-                    const score = this.getScore(player, obj);
-                    condition = condition && !matchesRange(score, range);
-                    rest = remaining.trim();
-                    continue;
-                }
-                // unless score <p1> <o1> <op> <p2> <o2>
-                const compareMatch = rest.match(/^(\S+)\s+(\S+)\s+([<>=]+)\s+(\S+)\s+(\S+)(.*)$/);
-                if (compareMatch) {
-                    const [, p1, o1, op, p2, o2, remaining] = compareMatch;
-                    const v1 = this.getScore(p1, o1);
-                    const v2 = this.getScore(p2, o2);
-                    let matches = false;
-                    switch (op) {
-                        case '=':
-                            matches = v1 === v2;
-                            break;
-                        case '<':
-                            matches = v1 < v2;
-                            break;
-                        case '<=':
-                            matches = v1 <= v2;
-                            break;
-                        case '>':
-                            matches = v1 > v2;
-                            break;
-                        case '>=':
-                            matches = v1 >= v2;
-                            break;
-                    }
-                    condition = condition && !matches; // unless = negate
-                    rest = remaining.trim();
-                    continue;
-                }
-            }
-            // Handle 'if entity <selector>'
-            if (rest.startsWith('if entity ')) {
-                rest = rest.slice(10);
-                const { selector, remaining } = this.parseNextSelector(rest);
-                rest = remaining;
-                const entities = parseSelector(selector, this.entities, currentExecutor);
-                condition = condition && entities.length > 0;
-                continue;
-            }
-            // Handle 'unless entity <selector>'
-            if (rest.startsWith('unless entity ')) {
-                rest = rest.slice(14);
-                const { selector, remaining } = this.parseNextSelector(rest);
-                rest = remaining;
-                const entities = parseSelector(selector, this.entities, currentExecutor);
-                condition = condition && entities.length === 0;
-                continue;
-            }
-            // Handle 'store result storage <ns:path> <field>[<idx>] <type> <scale>'  (array element)
-            if (rest.startsWith('store result storage ')) {
-                const sliced = rest.slice(21);
-                // Try array-index form first: <ns:path> <field>[<idx>] <type> <scale> <run-cmd>
-                // Use [^\[\s]+ for field (no brackets or spaces) so that \[ matches correctly.
-                const arrParts = sliced.match(/^(\S+)\s+([^\[\s]+)\[(\d+)\]\s+(\S+)\s+([\d.]+)\s+(.*)$/);
-                if (arrParts) {
-                    const [, storagePath, field, indexStr, , , remaining] = arrParts;
-                    storeTarget = { storagePath, field: `${field}[${indexStr}]`, type: 'result' };
-                    rest = remaining.trim();
-                    continue;
-                }
-                // Plain form: <ns:path> <field> <type> <scale> <run-cmd>
-                const storageParts = sliced.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/);
-                if (storageParts) {
-                    const [, storagePath, field, , , remaining] = storageParts;
-                    storeTarget = { storagePath, field, type: 'result' };
-                    rest = remaining.trim();
-                    continue;
-                }
-                rest = sliced;
-            }
-            // Handle 'store result score <player> <obj>'
-            if (rest.startsWith('store result score ')) {
-                rest = rest.slice(19);
-                const storeParts = rest.match(/^(\S+)\s+(\S+)(.*)$/);
-                if (storeParts) {
-                    const [, player, obj, remaining] = storeParts;
-                    storeTarget = { player, objective: obj, type: 'result' };
-                    rest = remaining.trim();
-                    continue;
-                }
-            }
-            // Handle 'store success score <player> <obj>'
-            if (rest.startsWith('store success score ')) {
-                rest = rest.slice(20);
-                const storeParts = rest.match(/^(\S+)\s+(\S+)(.*)$/);
-                if (storeParts) {
-                    const [, player, obj, remaining] = storeParts;
-                    storeTarget = { player, objective: obj, type: 'success' };
-                    rest = remaining.trim();
-                    continue;
-                }
-            }
-            // Unknown subcommand - skip to next space or 'run'
-            const nextSpace = rest.indexOf(' ');
-            if (nextSpace === -1)
-                break;
-            rest = rest.slice(nextSpace + 1);
-        }
-        if (storeTarget) {
-            const value = storeTarget.type === 'result'
-                ? (this.returnValue ?? (condition ? 1 : 0))
-                : (condition ? 1 : 0);
-            if ('storagePath' in storeTarget) {
-                this.setStorageField(storeTarget.storagePath, storeTarget.field, value);
-            }
-            else {
-                this.setScore(storeTarget.player, storeTarget.objective, value);
-            }
-        }
-        return condition;
-    }
-    parseNextSelector(input) {
-        input = input.trimStart();
-        const match = input.match(/^(@[eaps])(\[[^\]]*\])?/);
-        if (match) {
-            const selector = match[0];
-            return { selector, remaining: input.slice(selector.length).trim() };
-        }
-        // Non-selector target
-        const spaceIdx = input.indexOf(' ');
-        if (spaceIdx === -1) {
-            return { selector: input, remaining: '' };
-        }
-        return { selector: input.slice(0, spaceIdx), remaining: input.slice(spaceIdx + 1) };
-    }
-    // -------------------------------------------------------------------------
-    // Function Command
-    // -------------------------------------------------------------------------
-    execFunctionCmd(cmd, executor) {
-        let fnRef = cmd.slice(9).trim(); // remove 'function '
-        // Handle 'function ns:name with storage ns:path' — MC macro calling convention.
-        // The called function may have $( ) placeholders that need to be expanded
-        // using the provided storage compound. We execute the function after
-        // expanding its macro context.
-        const withStorageMatch = fnRef.match(/^(\S+)\s+with\s+storage\s+(\S+)$/);
-        if (withStorageMatch) {
-            const [, actualFnName, storagePath] = withStorageMatch;
-            const macroContext = this.getStorageCompound(storagePath) ?? {};
-            const outerShouldReturn = this.shouldReturn;
-            const outerMacroCtx = this.currentMacroContext;
-            this.currentMacroContext = macroContext;
-            this.execFunction(actualFnName, executor);
-            this.currentMacroContext = outerMacroCtx;
-            this.shouldReturn = outerShouldReturn;
-            return true;
-        }
-        const outerShouldReturn = this.shouldReturn;
-        this.execFunction(fnRef, executor);
-        this.shouldReturn = outerShouldReturn;
-        return true;
-    }
-    /** Expand MC macro placeholders: $(key) → value from currentMacroContext */
-    expandMacro(cmd) {
-        return cmd.replace(/\$\(([^)]+)\)/g, (_, key) => {
-            const val = this.currentMacroContext?.[key];
-            return val !== undefined ? String(val) : `$(${key})`;
-        });
-    }
-    // -------------------------------------------------------------------------
-    // Data Commands
-    // -------------------------------------------------------------------------
-    execData(cmd) {
-        // data modify storage <ns:path> <field> set value <val>
-        const setMatch = cmd.match(/^data modify storage (\S+) (\S+) set value (.+)$/);
-        if (setMatch) {
-            const [, storagePath, field, valueStr] = setMatch;
-            const value = this.parseDataValue(valueStr);
-            this.setStorageField(storagePath, field, value);
-            return true;
-        }
-        // data modify storage <ns:path> <field> append value <val>
-        const appendMatch = cmd.match(/^data modify storage (\S+) (\S+) append value (.+)$/);
-        if (appendMatch) {
-            const [, storagePath, field, valueStr] = appendMatch;
-            const value = this.parseDataValue(valueStr);
-            const current = this.getStorageField(storagePath, field) ?? [];
-            if (Array.isArray(current)) {
-                current.push(value);
-                this.setStorageField(storagePath, field, current);
-            }
-            return true;
-        }
-        // data modify storage <ns:path> <field>[<index>] set value <val>  (array element write)
-        const setArrMatch = cmd.match(/^data modify storage (\S+) ([^\[\s]+)\[(\d+)\] set value (.+)$/);
-        if (setArrMatch) {
-            const [, storagePath, field, indexStr, valueStr] = setArrMatch;
-            const arr = this.getStorageField(storagePath, field);
-            const idx = parseInt(indexStr, 10);
-            if (Array.isArray(arr) && idx >= 0 && idx < arr.length) {
-                arr[idx] = this.parseDataValue(valueStr);
-            }
-            return true;
-        }
-        // data get storage <ns:path> <field>[<index>] [scale]  (array element access)
-        const getArrMatch = cmd.match(/^data get storage (\S+) ([^\[\s]+)\[(\d+)\](?:\s+[\d.]+)?$/);
-        if (getArrMatch) {
-            const [, storagePath, field, indexStr] = getArrMatch;
-            const arr = this.getStorageField(storagePath, field);
-            const idx = parseInt(indexStr, 10);
-            const value = Array.isArray(arr) ? arr[idx] : undefined;
-            this.returnValue = typeof value === 'number' ? value : 0;
-            return true;
-        }
-        // data get storage <ns:path> <field> [scale]
-        const getMatch = cmd.match(/^data get storage (\S+) (\S+)(?:\s+[\d.]+)?$/);
-        if (getMatch) {
-            const [, storagePath, field] = getMatch;
-            const value = this.getStorageField(storagePath, field);
-            if (typeof value === 'number') {
-                this.returnValue = value;
-            }
-            else if (Array.isArray(value)) {
-                this.returnValue = value.length;
-            }
-            else {
-                this.returnValue = value ? 1 : 0;
-            }
-            return true;
-        }
-        // data modify storage <ns:path> <field> set from storage <src> <srcpath>
-        const copyMatch = cmd.match(/^data modify storage (\S+) (\S+) set from storage (\S+) (\S+)$/);
-        if (copyMatch) {
-            const [, dstPath, dstField, srcPath, srcField] = copyMatch;
-            const value = this.getStorageField(srcPath, srcField);
-            this.setStorageField(dstPath, dstField, value);
-            return true;
-        }
-        // data remove storage <ns:path> <field>
-        const removeMatch = cmd.match(/^data remove storage (\S+) (\S+)$/);
-        if (removeMatch) {
-            const [, storagePath, field] = removeMatch;
-            return this.removeStorageField(storagePath, field);
-        }
-        return false;
-    }
-    parseDataValue(str) {
-        str = str.trim();
-        // Try JSON parse
-        try {
-            return JSON.parse(str);
-        }
-        catch {
-            // Try numeric
-            const num = parseFloat(str);
-            if (!isNaN(num))
-                return num;
-            // Return as string
-            return str;
-        }
-    }
-    /** Return the whole storage compound at storagePath as a flat key→value map.
-     *  Used by 'function ... with storage' to provide macro context. */
-    getStorageCompound(storagePath) {
-        const data = this.storage.get(storagePath);
-        if (!data || typeof data !== 'object' || Array.isArray(data))
-            return null;
-        return data;
-    }
-    getStorageField(storagePath, field) {
-        const data = this.storage.get(storagePath) ?? {};
-        const segments = this.parseStoragePath(field);
-        let current = data;
-        for (const segment of segments) {
-            if (typeof segment === 'number') {
-                if (!Array.isArray(current))
-                    return undefined;
-                const index = segment < 0 ? current.length + segment : segment;
-                current = current[index];
-                continue;
-            }
-            if (current == null || typeof current !== 'object')
-                return undefined;
-            current = current[segment];
-        }
-        return current;
-    }
-    setStorageField(storagePath, field, value) {
-        let data = this.storage.get(storagePath);
-        if (!data) {
-            data = {};
-            this.storage.set(storagePath, data);
-        }
-        const segments = this.parseStoragePath(field);
-        let current = data;
-        for (let i = 0; i < segments.length - 1; i++) {
-            const segment = segments[i];
-            const next = segments[i + 1];
-            if (typeof segment === 'number') {
-                if (!Array.isArray(current))
-                    return;
-                const index = segment < 0 ? current.length + segment : segment;
-                if (current[index] === undefined) {
-                    current[index] = typeof next === 'number' ? [] : {};
-                }
-                current = current[index];
-                continue;
-            }
-            if (!(segment in current)) {
-                current[segment] = typeof next === 'number' ? [] : {};
-            }
-            current = current[segment];
-        }
-        const last = segments[segments.length - 1];
-        if (typeof last === 'number') {
-            if (!Array.isArray(current))
-                return;
-            const index = last < 0 ? current.length + last : last;
-            current[index] = value;
-            return;
-        }
-        current[last] = value;
-    }
-    removeStorageField(storagePath, field) {
-        const data = this.storage.get(storagePath);
-        if (!data)
-            return false;
-        const segments = this.parseStoragePath(field);
-        let current = data;
-        for (let i = 0; i < segments.length - 1; i++) {
-            const segment = segments[i];
-            if (typeof segment === 'number') {
-                if (!Array.isArray(current))
-                    return false;
-                const index = segment < 0 ? current.length + segment : segment;
-                current = current[index];
-            }
-            else {
-                current = current?.[segment];
-            }
-            if (current === undefined)
-                return false;
-        }
-        const last = segments[segments.length - 1];
-        if (typeof last === 'number') {
-            if (!Array.isArray(current))
-                return false;
-            const index = last < 0 ? current.length + last : last;
-            if (index < 0 || index >= current.length)
-                return false;
-            current.splice(index, 1);
-            return true;
-        }
-        if (current == null || typeof current !== 'object' || !(last in current))
-            return false;
-        delete current[last];
-        return true;
-    }
-    parseStoragePath(field) {
-        return field
-            .split('.')
-            .flatMap(part => {
-            const segments = [];
-            const regex = /([^\[\]]+)|\[(-?\d+)\]/g;
-            for (const match of part.matchAll(regex)) {
-                if (match[1])
-                    segments.push(match[1]);
-                if (match[2])
-                    segments.push(parseInt(match[2], 10));
-            }
-            return segments;
-        });
-    }
-    // -------------------------------------------------------------------------
-    // Tag Commands
-    // -------------------------------------------------------------------------
-    execTag(cmd, executor) {
-        // tag <selector> add <name>
-        const addMatch = cmd.match(/^tag (\S+) add (\S+)$/);
-        if (addMatch) {
-            const [, selStr, tagName] = addMatch;
-            const entities = selStr === '@s' && executor
-                ? [executor]
-                : parseSelector(selStr, this.entities, executor);
-            for (const entity of entities) {
-                entity.tags.add(tagName);
-            }
-            return entities.length > 0;
-        }
-        // tag <selector> remove <name>
-        const removeMatch = cmd.match(/^tag (\S+) remove (\S+)$/);
-        if (removeMatch) {
-            const [, selStr, tagName] = removeMatch;
-            const entities = selStr === '@s' && executor
-                ? [executor]
-                : parseSelector(selStr, this.entities, executor);
-            for (const entity of entities) {
-                entity.tags.delete(tagName);
-            }
-            return entities.length > 0;
-        }
-        return false;
-    }
-    // -------------------------------------------------------------------------
-    // Say/Tellraw/Title Commands
-    // -------------------------------------------------------------------------
-    execSay(cmd, executor) {
-        const message = cmd.slice(4);
-        this.chatLog.push(`[${executor?.id ?? 'Server'}] ${message}`);
-        return true;
-    }
-    execTellraw(cmd) {
-        // tellraw <selector> <json>
-        const match = cmd.match(/^tellraw \S+ (.+)$/);
-        if (match) {
-            const jsonStr = match[1];
-            const text = this.extractJsonText(jsonStr);
-            this.chatLog.push(text);
-            return true;
-        }
-        return false;
-    }
-    execTitle(cmd) {
-        // title <selector> <kind> <json>
-        const match = cmd.match(/^title \S+ (actionbar|title|subtitle) (.+)$/);
-        if (match) {
-            const [, kind, jsonStr] = match;
-            const text = this.extractJsonText(jsonStr);
-            this.chatLog.push(`[${kind.toUpperCase()}] ${text}`);
-            return true;
-        }
-        return false;
-    }
-    extractJsonText(json) {
-        if (typeof json === 'string') {
-            try {
-                json = JSON.parse(json);
-            }
-            catch {
-                return json;
-            }
-        }
-        if (typeof json === 'string')
-            return json;
-        if (Array.isArray(json)) {
-            return json.map(part => this.extractJsonText(part)).join('');
-        }
-        if (typeof json === 'object' && json !== null) {
-            if ('text' in json)
-                return String(json.text);
-            if ('score' in json && typeof json.score === 'object' && json.score !== null) {
-                const name = 'name' in json.score ? String(json.score.name) : '';
-                const objective = 'objective' in json.score ? String(json.score.objective) : 'rs';
-                return String(this.getScore(name, objective));
-            }
-            if ('extra' in json && Array.isArray(json.extra)) {
-                return json.extra.map((part) => this.extractJsonText(part)).join('');
-            }
-        }
-        return '';
-    }
-    // -------------------------------------------------------------------------
-    // World Commands
-    // -------------------------------------------------------------------------
-    execSetblock(cmd) {
-        const match = cmd.match(/^setblock (\S+) (\S+) (\S+) (\S+)$/);
-        if (!match)
-            return false;
-        const [, x, y, z, block] = match;
-        const key = this.positionKey(x, y, z);
-        if (!key)
-            return false;
-        this.world.set(key, block);
-        return true;
-    }
-    execFill(cmd) {
-        const match = cmd.match(/^fill (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+)$/);
-        if (!match)
-            return false;
-        const [, x1, y1, z1, x2, y2, z2, block] = match;
-        const start = this.parseAbsolutePosition(x1, y1, z1);
-        const end = this.parseAbsolutePosition(x2, y2, z2);
-        if (!start || !end)
-            return false;
-        const [minX, maxX] = [Math.min(start.x, end.x), Math.max(start.x, end.x)];
-        const [minY, maxY] = [Math.min(start.y, end.y), Math.max(start.y, end.y)];
-        const [minZ, maxZ] = [Math.min(start.z, end.z), Math.max(start.z, end.z)];
-        for (let x = minX; x <= maxX; x++) {
-            for (let y = minY; y <= maxY; y++) {
-                for (let z = minZ; z <= maxZ; z++) {
-                    this.world.set(`${x},${y},${z}`, block);
-                }
-            }
-        }
-        return true;
-    }
-    execTp(cmd, executor) {
-        const selfCoordsMatch = cmd.match(/^tp (\S+) (\S+) (\S+)$/);
-        if (selfCoordsMatch && executor) {
-            const [, x, y, z] = selfCoordsMatch;
-            const next = this.resolvePosition(executor.position ?? { x: 0, y: 0, z: 0 }, x, y, z);
-            if (!next)
-                return false;
-            executor.position = next;
-            return true;
-        }
-        const coordsMatch = cmd.match(/^tp (\S+) (\S+) (\S+) (\S+)$/);
-        if (coordsMatch) {
-            const [, selStr, x, y, z] = coordsMatch;
-            const entities = selStr === '@s' && executor
-                ? [executor]
-                : parseSelector(selStr, this.entities, executor);
-            for (const entity of entities) {
-                const next = this.resolvePosition(entity.position ?? { x: 0, y: 0, z: 0 }, x, y, z);
-                if (next) {
-                    entity.position = next;
-                }
-            }
-            return entities.length > 0;
-        }
-        const entityMatch = cmd.match(/^tp (\S+) (\S+)$/);
-        if (entityMatch) {
-            const [, selStr, targetStr] = entityMatch;
-            const entities = selStr === '@s' && executor
-                ? [executor]
-                : parseSelector(selStr, this.entities, executor);
-            const target = targetStr === '@s' && executor
-                ? executor
-                : parseSelector(targetStr, this.entities, executor)[0];
-            if (!target?.position)
-                return false;
-            for (const entity of entities) {
-                entity.position = { ...target.position };
-            }
-            return entities.length > 0;
-        }
-        return false;
-    }
-    execWeather(cmd) {
-        const match = cmd.match(/^weather (\S+)$/);
-        if (!match)
-            return false;
-        this.weather = match[1];
-        return true;
-    }
-    execTime(cmd) {
-        const match = cmd.match(/^time (set|add) (\S+)$/);
-        if (!match)
-            return false;
-        const [, action, valueStr] = match;
-        const value = this.parseTimeValue(valueStr);
-        if (value === null)
-            return false;
-        if (action === 'set') {
-            this.worldTime = value;
-        }
-        else {
-            this.worldTime += value;
-        }
-        return true;
-    }
-    // -------------------------------------------------------------------------
-    // Kill Command
-    // -------------------------------------------------------------------------
-    execKill(cmd, executor) {
-        const selStr = cmd.slice(5).trim();
-        if (selStr === '@s' && executor) {
-            this.entities = this.entities.filter(e => e !== executor);
-            return true;
-        }
-        const entities = parseSelector(selStr, this.entities, executor);
-        for (const entity of entities) {
-            this.entities = this.entities.filter(e => e !== entity);
-        }
-        return entities.length > 0;
-    }
-    // -------------------------------------------------------------------------
-    // Effect / XP Commands
-    // -------------------------------------------------------------------------
-    execEffect(cmd, executor) {
-        const match = cmd.match(/^effect give (\S+) (\S+)(?: (\S+))?(?: (\S+))?(?: \S+)?$/);
-        if (!match)
-            return false;
-        const [, selStr, effect, durationStr, amplifierStr] = match;
-        const entities = selStr === '@s' && executor
-            ? [executor]
-            : parseSelector(selStr, this.entities, executor);
-        const duration = durationStr ? parseInt(durationStr, 10) : 30;
-        const amplifier = amplifierStr ? parseInt(amplifierStr, 10) : 0;
-        for (const entity of entities) {
-            const current = this.effects.get(entity.id) ?? [];
-            current.push({ effect, duration: isNaN(duration) ? 30 : duration, amplifier: isNaN(amplifier) ? 0 : amplifier });
-            this.effects.set(entity.id, current);
-        }
-        return entities.length > 0;
-    }
-    execXp(cmd, executor) {
-        const match = cmd.match(/^xp (add|set) (\S+) (-?\d+)(?: (\S+))?$/);
-        if (!match)
-            return false;
-        const [, action, target, amountStr] = match;
-        const amount = parseInt(amountStr, 10);
-        const keys = this.resolveTargetKeys(target, executor);
-        if (keys.length === 0)
-            return false;
-        for (const key of keys) {
-            const current = this.xp.get(key) ?? 0;
-            this.xp.set(key, action === 'set' ? amount : current + amount);
-        }
-        return true;
-    }
-    // -------------------------------------------------------------------------
-    // Summon Command
-    // -------------------------------------------------------------------------
-    execSummon(cmd) {
-        // summon minecraft:armor_stand <x> <y> <z> {Tags:["tag1","tag2"]}
-        const match = cmd.match(/^summon (\S+) (\S+) (\S+) (\S+) ({.+})$/);
-        if (match) {
-            const [, type, x, y, z, nbtStr] = match;
-            const nbt = parseNBT(nbtStr);
-            const position = this.parseAbsolutePosition(x, y, z) ?? { x: 0, y: 0, z: 0 };
-            this.spawnEntity(nbt.Tags || [], type, position);
-            return true;
-        }
-        // Simple summon without NBT
-        const simpleMatch = cmd.match(/^summon (\S+)(?: (\S+) (\S+) (\S+))?$/);
-        if (simpleMatch) {
-            const [, type, x, y, z] = simpleMatch;
-            const position = x && y && z
-                ? (this.parseAbsolutePosition(x, y, z) ?? { x: 0, y: 0, z: 0 })
-                : { x: 0, y: 0, z: 0 };
-            this.spawnEntity([], type, position);
-            return true;
-        }
-        return false;
-    }
-    // -------------------------------------------------------------------------
-    // Return Command
-    // -------------------------------------------------------------------------
-    execReturn(cmd, executor) {
-        const rest = cmd.slice(7).trim();
-        // return run <cmd>
-        if (rest.startsWith('run ')) {
-            const innerCmd = rest.slice(4);
-            this.execCommand(innerCmd, executor);
-            this.shouldReturn = true;
-            return true;
-        }
-        // return <value>
-        const value = parseInt(rest, 10);
-        if (!isNaN(value)) {
-            this.returnValue = value;
-            this.shouldReturn = true;
-            return true;
-        }
-        return false;
-    }
-    // -------------------------------------------------------------------------
-    // Scoreboard Helpers
-    // -------------------------------------------------------------------------
-    getScore(player, objective) {
-        const obj = this.scoreboard.get(objective);
-        if (!obj)
-            return 0;
-        return obj.get(player) ?? 0;
-    }
-    setScore(player, objective, value) {
-        let obj = this.scoreboard.get(objective);
-        if (!obj) {
-            obj = new Map();
-            this.scoreboard.set(objective, obj);
-        }
-        obj.set(player, value);
-    }
-    addScore(player, objective, delta) {
-        const current = this.getScore(player, objective);
-        this.setScore(player, objective, current + delta);
-    }
-    // -------------------------------------------------------------------------
-    // Storage Helpers
-    // -------------------------------------------------------------------------
-    getStorage(path) {
-        // "ns:path.field" → parse namespace and nested fields
-        const colonIdx = path.indexOf(':');
-        if (colonIdx === -1)
-            return this.storage.get(path);
-        const nsPath = path.slice(0, colonIdx + 1) + path.slice(colonIdx + 1).split('.')[0];
-        const field = path.slice(colonIdx + 1).includes('.')
-            ? path.slice(path.indexOf('.', colonIdx) + 1)
-            : undefined;
-        if (!field)
-            return this.storage.get(nsPath);
-        return this.getStorageField(nsPath, field);
-    }
-    setStorage(path, value) {
-        const colonIdx = path.indexOf(':');
-        if (colonIdx === -1) {
-            this.storage.set(path, value);
-            return;
-        }
-        const basePath = path.slice(0, colonIdx + 1) + path.slice(colonIdx + 1).split('.')[0];
-        const field = path.slice(colonIdx + 1).includes('.')
-            ? path.slice(path.indexOf('.', colonIdx) + 1)
-            : undefined;
-        if (!field) {
-            this.storage.set(basePath, value);
-            return;
-        }
-        this.setStorageField(basePath, field, value);
-    }
-    // -------------------------------------------------------------------------
-    // Entity Helpers
-    // -------------------------------------------------------------------------
-    spawnEntity(tags, type = 'minecraft:armor_stand', position = { x: 0, y: 0, z: 0 }) {
-        const id = `entity_${this.entityIdCounter++}`;
-        const entity = {
-            id,
-            tags: new Set(tags),
-            scores: new Map(),
-            selector: `@e[tag=${tags[0] ?? id},limit=1]`,
-            type,
-            position,
-        };
-        this.entities.push(entity);
-        return entity;
-    }
-    killEntity(tag) {
-        this.entities = this.entities.filter(e => !e.tags.has(tag));
-    }
-    getEntities(selector) {
-        return parseSelector(selector, this.entities);
-    }
-    positionKey(x, y, z) {
-        const pos = this.parseAbsolutePosition(x, y, z);
-        return pos ? `${pos.x},${pos.y},${pos.z}` : null;
-    }
-    parseAbsolutePosition(x, y, z) {
-        const coords = [x, y, z].map(coord => {
-            if (coord.startsWith('~') || coord.startsWith('^')) {
-                const offset = coord.slice(1);
-                return offset === '' ? 0 : parseInt(offset, 10);
-            }
-            return parseInt(coord, 10);
-        });
-        if (coords.some(Number.isNaN))
-            return null;
-        return { x: coords[0], y: coords[1], z: coords[2] };
-    }
-    resolvePosition(base, x, y, z) {
-        const values = [x, y, z].map((coord, index) => {
-            if (coord.startsWith('~') || coord.startsWith('^')) {
-                const offset = coord.slice(1);
-                const delta = offset === '' ? 0 : parseInt(offset, 10);
-                return [base.x, base.y, base.z][index] + delta;
-            }
-            return parseInt(coord, 10);
-        });
-        if (values.some(Number.isNaN))
-            return null;
-        return { x: values[0], y: values[1], z: values[2] };
-    }
-    parseTimeValue(value) {
-        if (/^-?\d+$/.test(value)) {
-            return parseInt(value, 10);
-        }
-        const aliases = {
-            day: 1000,
-            noon: 6000,
-            night: 13000,
-            midnight: 18000,
-            sunrise: 23000,
-        };
-        return aliases[value] ?? null;
-    }
-    resolveTargetKeys(target, executor) {
-        if (target.startsWith('@')) {
-            const entities = target === '@s' && executor
-                ? [executor]
-                : parseSelector(target, this.entities, executor);
-            return entities.map(entity => entity.id);
-        }
-        return [target];
-    }
-    // -------------------------------------------------------------------------
-    // Output Helpers
-    // -------------------------------------------------------------------------
-    getLastSaid() {
-        return this.chatLog[this.chatLog.length - 1] ?? '';
-    }
-    getChatLog() {
-        return [...this.chatLog];
-    }
-    // -------------------------------------------------------------------------
-    // Convenience: Compile and Load
-    // -------------------------------------------------------------------------
-    compileAndLoad(source) {
-        const result = (0, compile_1.compile)(source, { namespace: this.namespace });
-        if (!result.success || !result.files) {
-            throw new Error('Compilation failed');
-        }
-        // Load all .mcfunction files
-        for (const file of result.files) {
-            if (file.path.endsWith('.mcfunction')) {
-                // Extract function name from path
-                // e.g., "data/test/function/increment.mcfunction" → "test:increment"
-                const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
-                if (match) {
-                    const [, ns, fnPath] = match;
-                    const fnName = `${ns}:${fnPath.replace(/\//g, '/')}`;
-                    this.loadFunction(fnName, file.content.split('\n'));
-                }
-            }
-        }
-        // Run load function
-        this.load();
-    }
-}
-exports.MCRuntime = MCRuntime;
-//# sourceMappingURL=index.js.map