redscript-mc 1.0.0

package/dist/data/shop/function/complete_purchase/merge_5.mcfunction

@@ -0,0 +1,2 @@
+# block: merge_5
+function shop:complete_purchase/merge_2

package/dist/data/shop/function/complete_purchase/merge_8.mcfunction

@@ -0,0 +1,2 @@
+# block: merge_8
+function shop:complete_purchase/merge_5

package/dist/data/shop/function/complete_purchase/then_0.mcfunction

@@ -0,0 +1,4 @@
+# block: then_0
+give @s minecraft:bread 1
+tellraw @s {"text":"You bought bread."}
+function shop:complete_purchase/merge_2

package/dist/data/shop/function/complete_purchase/then_3.mcfunction

@@ -0,0 +1,4 @@
+# block: then_3
+give @s minecraft:steak 1
+tellraw @s {"text":"You bought steak."}
+function shop:complete_purchase/merge_5

package/dist/data/shop/function/complete_purchase/then_6.mcfunction

@@ -0,0 +1,4 @@
+# block: then_6
+give @s minecraft:diamond 1
+tellraw @s {"text":"You bought a diamond."}
+function shop:complete_purchase/merge_8

package/dist/data/shop/function/complete_purchase.mcfunction

@@ -0,0 +1,7 @@
+# block: entry
+execute store result score $t0 rs run scoreboard players get @s shop_choice
+scoreboard players operation $choice rs = $t0 rs
+scoreboard players set $t1 rs 0
+execute if score $t0 rs = $const_1 rs run scoreboard players set $t1 rs 1
+execute if score $t1 rs matches 1.. run function shop:complete_purchase/then_0
+execute if score $t1 rs matches ..0 run function shop:complete_purchase/else_1

package/dist/data/shop/function/handle_shop_trigger.mcfunction

@@ -0,0 +1,3 @@
+# block: entry
+function shop:complete_purchase
+scoreboard players operation $t0 rs = $ret rs

package/dist/data/turret/function/__load.mcfunction

@@ -0,0 +1,5 @@
+# RedScript runtime init
+scoreboard objectives add rs dummy
+scoreboard players set $__tick_turret_tick rs 0
+scoreboard objectives add deploy_turret trigger
+scoreboard players enable @a deploy_turret

package/dist/data/turret/function/__tick.mcfunction

@@ -0,0 +1,4 @@
+# RedScript tick dispatcher
+function turret:turret_tick
+# Trigger checks
+execute as @a[scores={deploy_turret=1..}] run function turret:__trigger_deploy_turret_dispatch

package/dist/data/turret/function/__trigger_deploy_turret_dispatch.mcfunction

@@ -0,0 +1,4 @@
+# Trigger dispatch for deploy_turret
+function turret:deploy_turret
+scoreboard players set @s deploy_turret 0
+scoreboard players enable @s deploy_turret

package/dist/data/turret/function/deploy_turret.mcfunction

@@ -0,0 +1,8 @@
+# block: entry
+summon minecraft:armor_stand 0 64 0 {Invisible:1b,Marker:1b,NoGravity:1b,Tags:["__rs_obj_0"]}
+scoreboard players set @e[tag=__rs_obj_0,limit=1] rs 40
+tag @e[tag=__rs_obj_0,limit=1] add turret
+data modify storage rs:heap turretstate_state.health set value 40
+execute store result score $t0 rs run data get storage rs:heap turretstate_state.health
+execute store result score turret health run scoreboard players get $t1 rs
+say Turret deployed.

package/dist/data/turret/function/turret_tick/at_1.mcfunction

@@ -0,0 +1,2 @@
+# block: entry
+execute as @e[type=zombie,distance=..8] run function turret:turret_tick/foreach_2

package/dist/data/turret/function/turret_tick/foreach_0.mcfunction

@@ -0,0 +1,2 @@
+# block: entry
+execute at @s run function turret:turret_tick/at_1

package/dist/data/turret/function/turret_tick/foreach_2.mcfunction

@@ -0,0 +1,2 @@
+# block: entry
+kill @s

package/dist/data/turret/function/turret_tick/tick_body.mcfunction

@@ -0,0 +1,3 @@
+# block: tick_body
+scoreboard players set $__tick_turret_tick rs 0
+execute as @e[type=armor_stand,tag=turret] run function turret:turret_tick/foreach_0

package/dist/data/turret/function/turret_tick/tick_skip.mcfunction

@@ -0,0 +1 @@
+# block: tick_skip

package/dist/data/turret/function/turret_tick.mcfunction

@@ -0,0 +1,5 @@
+# block: entry
+scoreboard players add $__tick_turret_tick rs 1
+execute store success score $__tick_turret_tick_check rs if score $__tick_turret_tick rs matches 20..
+execute if score $__tick_turret_tick_check rs matches 1.. run function turret:turret_tick/tick_body
+execute if score $__tick_turret_tick_check rs matches ..0 run function turret:turret_tick/tick_skip

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * RedScript Diagnostics
+ *
+ * Error reporting with file path, line, column, and formatted error messages.
+ */
+export type DiagnosticKind = 'LexError' | 'ParseError' | 'LoweringError' | 'TypeError';
+export interface DiagnosticLocation {
+    file?: string;
+    line: number;
+    col: number;
+}
+export declare class DiagnosticError extends Error {
+    readonly kind: DiagnosticKind;
+    readonly location: DiagnosticLocation;
+    readonly sourceLines?: string[];
+    constructor(kind: DiagnosticKind, message: string, location: DiagnosticLocation, sourceLines?: string[]);
+    /**
+     * Format the error for display:
+     * ```
+     * Error: [ParseError] line 5, col 12: Expected ';' after statement
+     *   5 |   let x = 42
+     *                   ^ expected ';'
+     * ```
+     */
+    format(): string;
+    toString(): string;
+}
+export declare class DiagnosticCollector {
+    private diagnostics;
+    private sourceLines;
+    private filePath?;
+    constructor(source?: string, filePath?: string);
+    error(kind: DiagnosticKind, message: string, line: number, col: number): void;
+    hasErrors(): boolean;
+    getErrors(): DiagnosticError[];
+    formatAll(): string;
+    throwFirst(): never;
+}
+/**
+ * Create a DiagnosticError from a raw error message that includes line/col info
+ * 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;

package/dist/diagnostics/index.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * RedScript Diagnostics
+ *
+ * Error reporting with file path, line, column, and formatted error messages.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticCollector = exports.DiagnosticError = void 0;
+exports.parseErrorMessage = parseErrorMessage;
+exports.formatError = formatError;
+function formatSourcePointer(sourceLines, line, col) {
+    const lineIdx = line - 1;
+    if (lineIdx < 0 || lineIdx >= sourceLines.length) {
+        return [];
+    }
+    const sourceLine = sourceLines[lineIdx];
+    const safeCol = Math.max(1, Math.min(col, sourceLine.length + 1));
+    const pointer = `  ${' '.repeat(safeCol - 1)}^`;
+    return [`  ${sourceLine}`, pointer];
+}
+class DiagnosticError extends Error {
+    constructor(kind, message, location, sourceLines) {
+        super(message);
+        this.name = 'DiagnosticError';
+        this.kind = kind;
+        this.location = location;
+        this.sourceLines = sourceLines;
+    }
+    /**
+     * Format the error for display:
+     * ```
+     * Error: [ParseError] line 5, col 12: Expected ';' after statement
+     *   5 |   let x = 42
+     *                   ^ expected ';'
+     * ```
+     */
+    format() {
+        const { kind, message, location, sourceLines } = this;
+        const filePart = location.file ? `${location.file}:` : '';
+        const header = `Error: [${kind}] ${filePart}line ${location.line}, col ${location.col}: ${message}`;
+        if (!sourceLines || sourceLines.length === 0) {
+            return header;
+        }
+        const pointerLines = formatSourcePointer(sourceLines, location.line, location.col);
+        if (pointerLines.length === 0) {
+            return header;
+        }
+        const lineNum = String(location.line).padStart(3);
+        const prefix = `${lineNum} | `;
+        const sourceLine = sourceLines[location.line - 1];
+        const safeCol = Math.max(1, Math.min(location.col, sourceLine.length + 1));
+        const pointer = ' '.repeat(prefix.length + safeCol - 1) + '^';
+        const hint = message.toLowerCase().includes('expected')
+            ? message.split(':').pop()?.trim() || ''
+            : '';
+        return [
+            header,
+            `${prefix}${sourceLine}`,
+            `${pointer}${hint ? ` ${hint}` : ''}`,
+        ].join('\n');
+    }
+    toString() {
+        return this.format();
+    }
+}
+exports.DiagnosticError = DiagnosticError;
+// ---------------------------------------------------------------------------
+// Diagnostic Collection
+// ---------------------------------------------------------------------------
+class DiagnosticCollector {
+    constructor(source, filePath) {
+        this.diagnostics = [];
+        this.sourceLines = [];
+        if (source) {
+            this.sourceLines = source.split('\n');
+        }
+        this.filePath = filePath;
+    }
+    error(kind, message, line, col) {
+        const diagnostic = new DiagnosticError(kind, message, { file: this.filePath, line, col }, this.sourceLines);
+        this.diagnostics.push(diagnostic);
+    }
+    hasErrors() {
+        return this.diagnostics.length > 0;
+    }
+    getErrors() {
+        return this.diagnostics;
+    }
+    formatAll() {
+        return this.diagnostics.map(d => d.format()).join('\n\n');
+    }
+    throwFirst() {
+        if (this.diagnostics.length > 0) {
+            throw this.diagnostics[0];
+        }
+        throw new Error('No diagnostics to throw');
+    }
+}
+exports.DiagnosticCollector = DiagnosticCollector;
+// ---------------------------------------------------------------------------
+// Helper Functions
+// ---------------------------------------------------------------------------
+/**
+ * Create a DiagnosticError from a raw error message that includes line/col info
+ * e.g., "Expected ';' at line 5, col 12"
+ */
+function parseErrorMessage(kind, rawMessage, sourceLines, filePath) {
+    // Try to extract line and col from message
+    const match = rawMessage.match(/at line (\d+), col (\d+)/);
+    if (match) {
+        const line = parseInt(match[1], 10);
+        const col = parseInt(match[2], 10);
+        const message = rawMessage.replace(/ at line \d+, col \d+$/, '').trim();
+        return new DiagnosticError(kind, message, { file: filePath, line, col }, sourceLines);
+    }
+    // Fallback: line 1, col 1
+    return new DiagnosticError(kind, rawMessage, { file: filePath, line: 1, col: 1 }, sourceLines);
+}
+function formatError(error, source) {
+    if (error instanceof DiagnosticError) {
+        const sourceLines = source?.split('\n') ?? error.sourceLines ?? [];
+        const { file, line, col } = error.location;
+        const locationPart = file
+            ? ` in ${file} at line ${line}, col ${col}`
+            : ` at line ${line}, col ${col}`;
+        const lines = [`Error${locationPart}:`];
+        const pointerLines = formatSourcePointer(sourceLines, line, col);
+        if (pointerLines.length > 0) {
+            lines.push(...pointerLines);
+        }
+        lines.push(error.message);
+        return lines.join('\n');
+    }
+    if (!source) {
+        return error.message;
+    }
+    const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'));
+    return formatError(parsed, source);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * RedScript Compiler
+ *
+ * Main entry point for programmatic usage.
+ */
+import type { Warning } from './lowering';
+import { DatapackFile } from './codegen/mcfunction';
+import type { IRModule } from './ir/types';
+import type { Program } from './ast/types';
+import type { DiagnosticError } from './diagnostics';
+import { type OptimizationStats } from './optimizer/commands';
+export interface CompileOptions {
+    namespace?: string;
+    optimize?: boolean;
+    typeCheck?: boolean;
+    filePath?: string;
+}
+export interface CompileResult {
+    files: DatapackFile[];
+    advancements: DatapackFile[];
+    ast: Program;
+    ir: IRModule;
+    typeErrors?: DiagnosticError[];
+    warnings?: Warning[];
+    stats?: OptimizationStats;
+}
+/**
+ * Compile RedScript source code to a Minecraft datapack.
+ *
+ * @param source - The RedScript source code
+ * @param options - Compilation options
+ * @returns Compiled datapack files
+ */
+export declare function compile(source: string, options?: CompileOptions): CompileResult;
+/**
+ * Check RedScript source code for errors without generating output.
+ *
+ * @param source - The RedScript source code
+ * @param namespace - Optional namespace
+ * @returns null if no errors, or an error object
+ */
+export declare function check(source: string, namespace?: string, filePath?: string): Error | null;
+export { Lexer } from './lexer';
+export { Parser } from './parser';
+export { TypeChecker } from './typechecker';
+export { Lowering } from './lowering';
+export { optimize } from './optimizer/passes';
+export { generateDatapack } from './codegen/mcfunction';
+export { MCCommandValidator } from './mc-validator';
+export type { DatapackFile } from './codegen/mcfunction';
+export type { IRModule, IRFunction } from './ir/types';
+export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types';
+export type { DiagnosticError } from './diagnostics';

package/dist/index.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * RedScript Compiler
+ *
+ * Main entry point for programmatic usage.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCCommandValidator = exports.generateDatapack = exports.optimize = exports.Lowering = exports.TypeChecker = exports.Parser = exports.Lexer = void 0;
+exports.compile = compile;
+exports.check = check;
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const typechecker_1 = require("./typechecker");
+const lowering_1 = require("./lowering");
+const passes_1 = require("./optimizer/passes");
+const mcfunction_1 = require("./codegen/mcfunction");
+const compile_1 = require("./compile");
+const commands_1 = require("./optimizer/commands");
+/**
+ * Compile RedScript source code to a Minecraft datapack.
+ *
+ * @param source - The RedScript source code
+ * @param options - Compilation options
+ * @returns Compiled datapack files
+ */
+function compile(source, options = {}) {
+    const namespace = options.namespace ?? 'redscript';
+    const shouldOptimize = options.optimize ?? true;
+    const shouldTypeCheck = options.typeCheck ?? true;
+    const filePath = options.filePath;
+    const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
+    // Lexing
+    const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
+    // Parsing
+    const ast = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+    // Type checking (warn mode - collect errors but don't block)
+    let typeErrors;
+    if (shouldTypeCheck) {
+        const checker = new typechecker_1.TypeChecker(preprocessedSource, filePath);
+        typeErrors = checker.check(ast);
+    }
+    // Lowering to IR
+    const lowering = new lowering_1.Lowering(namespace);
+    const ir = lowering.lower(ast);
+    let optimizedIR = ir;
+    let generated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: shouldOptimize });
+    let optimizationStats;
+    if (shouldOptimize) {
+        const stats = (0, commands_1.createEmptyOptimizationStats)();
+        const copyPropagatedFunctions = [];
+        const deadCodeEliminatedFunctions = [];
+        for (const fn of ir.functions) {
+            const folded = (0, passes_1.constantFoldingWithStats)(fn);
+            stats.constantFolds += folded.stats.constantFolds ?? 0;
+            const propagated = (0, passes_1.copyPropagation)(folded.fn);
+            copyPropagatedFunctions.push(propagated);
+            const dce = (0, passes_1.deadCodeEliminationWithStats)(propagated);
+            deadCodeEliminatedFunctions.push(dce.fn);
+        }
+        const copyPropagatedIR = { ...ir, functions: copyPropagatedFunctions };
+        optimizedIR = { ...ir, functions: deadCodeEliminatedFunctions };
+        const baselineGenerated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: false });
+        const beforeDceGenerated = (0, mcfunction_1.generateDatapackWithStats)(copyPropagatedIR, { optimizeCommands: false });
+        const afterDceGenerated = (0, mcfunction_1.generateDatapackWithStats)(optimizedIR, { optimizeCommands: false });
+        generated = (0, mcfunction_1.generateDatapackWithStats)(optimizedIR, { optimizeCommands: true });
+        stats.deadCodeRemoved =
+            (0, mcfunction_1.countMcfunctionCommands)(beforeDceGenerated.files) - (0, mcfunction_1.countMcfunctionCommands)(afterDceGenerated.files);
+        stats.licmHoists = generated.stats.licmHoists;
+        stats.licmLoopBodies = generated.stats.licmLoopBodies;
+        stats.cseRedundantReads = generated.stats.cseRedundantReads;
+        stats.cseArithmetic = generated.stats.cseArithmetic;
+        stats.setblockMergedCommands = generated.stats.setblockMergedCommands;
+        stats.setblockFillCommands = generated.stats.setblockFillCommands;
+        stats.setblockSavedCommands = generated.stats.setblockSavedCommands;
+        stats.totalCommandsBefore = (0, mcfunction_1.countMcfunctionCommands)(baselineGenerated.files);
+        stats.totalCommandsAfter = (0, mcfunction_1.countMcfunctionCommands)(generated.files);
+        optimizationStats = stats;
+    }
+    else {
+        optimizedIR = ir;
+        generated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: false });
+    }
+    return {
+        files: [...generated.files, ...generated.advancements],
+        advancements: generated.advancements,
+        ast,
+        ir: optimizedIR,
+        typeErrors,
+        warnings: lowering.warnings,
+        stats: optimizationStats,
+    };
+}
+/**
+ * Check RedScript source code for errors without generating output.
+ *
+ * @param source - The RedScript source code
+ * @param namespace - Optional namespace
+ * @returns null if no errors, or an error object
+ */
+function check(source, namespace = 'redscript', filePath) {
+    try {
+        const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
+        const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
+        new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+        return null;
+    }
+    catch (err) {
+        return err;
+    }
+}
+// Re-export types and classes for advanced usage
+var lexer_2 = require("./lexer");
+Object.defineProperty(exports, "Lexer", { enumerable: true, get: function () { return lexer_2.Lexer; } });
+var parser_2 = require("./parser");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_2.Parser; } });
+var typechecker_2 = require("./typechecker");
+Object.defineProperty(exports, "TypeChecker", { enumerable: true, get: function () { return typechecker_2.TypeChecker; } });
+var lowering_2 = require("./lowering");
+Object.defineProperty(exports, "Lowering", { enumerable: true, get: function () { return lowering_2.Lowering; } });
+var passes_2 = require("./optimizer/passes");
+Object.defineProperty(exports, "optimize", { enumerable: true, get: function () { return passes_2.optimize; } });
+var mcfunction_2 = require("./codegen/mcfunction");
+Object.defineProperty(exports, "generateDatapack", { enumerable: true, get: function () { return mcfunction_2.generateDatapack; } });
+var mc_validator_1 = require("./mc-validator");
+Object.defineProperty(exports, "MCCommandValidator", { enumerable: true, get: function () { return mc_validator_1.MCCommandValidator; } });
+//# sourceMappingURL=index.js.map

package/dist/ir/builder.d.ts

@@ -0,0 +1,32 @@
+/**
+ * IRBuilder — helper for constructing IR programmatically.
+ * AST → IR lowering uses this.
+ */
+import type { IRFunction, IRInstr, IRModule, Operand } from './types';
+export declare class IRBuilder {
+    private tempCount;
+    private labelCount;
+    private currentBlock;
+    private blocks;
+    private locals;
+    freshTemp(): string;
+    freshLabel(hint?: string): string;
+    startBlock(label: string): void;
+    private get block();
+    private sealBlock;
+    emitAssign(dst: string, src: Operand): void;
+    emitBinop(dst: string, lhs: Operand, bop: IRInstr & {
+        op: 'binop';
+    } extends {
+        bop: infer B;
+    } ? B : never, rhs: Operand): void;
+    emitCmp(dst: string, lhs: Operand, cop: '==' | '!=' | '<' | '<=' | '>' | '>=', rhs: Operand): void;
+    emitCall(fn: string, args: Operand[], dst?: string): void;
+    emitRaw(cmd: string): void;
+    emitJump(target: string): void;
+    emitJumpIf(cond: string, then: string, else_: string): void;
+    emitReturn(value?: Operand): void;
+    emitTickYield(continuation: string): void;
+    build(name: string, params: string[], isTickLoop?: boolean): IRFunction;
+}
+export declare function buildModule(namespace: string, fns: IRFunction[], globals?: string[]): IRModule;

package/dist/ir/builder.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * IRBuilder — helper for constructing IR programmatically.
+ * AST → IR lowering uses this.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRBuilder = void 0;
+exports.buildModule = buildModule;
+class IRBuilder {
+    constructor() {
+        this.tempCount = 0;
+        this.labelCount = 0;
+        this.currentBlock = null;
+        this.blocks = [];
+        this.locals = new Set();
+    }
+    // -------------------------------------------------------------------------
+    // Names
+    // -------------------------------------------------------------------------
+    freshTemp() {
+        const name = `$t${this.tempCount++}`;
+        this.locals.add(name);
+        return name;
+    }
+    freshLabel(hint = 'L') {
+        return `${hint}_${this.labelCount++}`;
+    }
+    // -------------------------------------------------------------------------
+    // Block management
+    // -------------------------------------------------------------------------
+    startBlock(label) {
+        this.currentBlock = { label, instrs: [], term: { op: 'return' } };
+    }
+    get block() {
+        if (!this.currentBlock)
+            throw new Error('No active block');
+        return this.currentBlock;
+    }
+    sealBlock(term) {
+        this.block.term = term;
+        this.blocks.push(this.block);
+        this.currentBlock = null;
+    }
+    // -------------------------------------------------------------------------
+    // Emit instructions
+    // -------------------------------------------------------------------------
+    emitAssign(dst, src) {
+        this.locals.add(dst);
+        this.block.instrs.push({ op: 'assign', dst, src });
+    }
+    emitBinop(dst, lhs, bop, rhs) {
+        this.locals.add(dst);
+        this.block.instrs.push({ op: 'binop', dst, lhs, bop, rhs });
+    }
+    emitCmp(dst, lhs, cop, rhs) {
+        this.locals.add(dst);
+        this.block.instrs.push({ op: 'cmp', dst, lhs, cop, rhs });
+    }
+    emitCall(fn, args, dst) {
+        if (dst)
+            this.locals.add(dst);
+        this.block.instrs.push({ op: 'call', fn, args, dst });
+    }
+    emitRaw(cmd) {
+        this.block.instrs.push({ op: 'raw', cmd });
+    }
+    // -------------------------------------------------------------------------
+    // Terminators
+    // -------------------------------------------------------------------------
+    emitJump(target) {
+        this.sealBlock({ op: 'jump', target });
+    }
+    emitJumpIf(cond, then, else_) {
+        this.sealBlock({ op: 'jump_if', cond, then, else_ });
+    }
+    emitReturn(value) {
+        this.sealBlock({ op: 'return', value });
+    }
+    emitTickYield(continuation) {
+        this.sealBlock({ op: 'tick_yield', continuation });
+    }
+    // -------------------------------------------------------------------------
+    // Build
+    // -------------------------------------------------------------------------
+    build(name, params, isTickLoop = false) {
+        return {
+            name,
+            params,
+            locals: Array.from(this.locals),
+            blocks: this.blocks,
+            isTickLoop,
+        };
+    }
+}
+exports.IRBuilder = IRBuilder;
+function buildModule(namespace, fns, globals = []) {
+    return { namespace, functions: fns, globals };
+}
+//# sourceMappingURL=builder.js.map