redscript-mc 1.2.29 → 2.0.0

package/dist/src/mc-validator/index.js

@@ -0,0 +1,322 @@
+"use strict";
+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.MCCommandValidator = void 0;
+const fs = __importStar(require("fs"));
+const FUNCTION_ID_RE = /^[0-9a-z_.-]+:[0-9a-z_./-]+$/i;
+const INTEGER_RE = /^-?\d+$/;
+const SCORE_RANGE_RE = /^-?\d+\.\.$|^\.\.-?\d+$|^-?\d+\.\.-?\d+$|^-?\d+$/;
+const COMMENT_PREFIXES = [
+    '# RedScript runtime init',
+    '# block:',
+    '# RedScript tick dispatcher',
+];
+const SCOREBOARD_PLAYER_ACTIONS = new Set(['set', 'add', 'remove', 'get', 'operation', 'enable']);
+const SCOREBOARD_OPERATIONS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '<', '>', '><']);
+class MCCommandValidator {
+    constructor(commandsPath) {
+        const parsed = JSON.parse(fs.readFileSync(commandsPath, 'utf-8'));
+        this.root = parsed.root;
+        this.rootChildren = parsed.root.children ?? [];
+    }
+    validate(line) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || COMMENT_PREFIXES.some(prefix => trimmed.startsWith(prefix))) {
+            return { valid: true };
+        }
+        const tokens = tokenize(trimmed);
+        if (tokens.length === 0) {
+            return { valid: true };
+        }
+        if (!this.hasRootCommand(tokens[0])) {
+            return { valid: false, error: `Unknown root command: ${tokens[0]}` };
+        }
+        switch (tokens[0]) {
+            case 'execute':
+                return this.validateExecute(tokens);
+            case 'scoreboard':
+                return this.validateScoreboard(tokens);
+            case 'function':
+                return this.validateFunction(tokens);
+            case 'data':
+                return this.validateData(tokens);
+            case 'return':
+                return this.validateReturn(tokens);
+            default:
+                return this.validateAgainstTree(tokens);
+        }
+    }
+    hasRootCommand(command) {
+        return this.rootChildren.some(child => child.type === 'literal' && child.name === command);
+    }
+    validateExecute(tokens) {
+        const runIndex = tokens.indexOf('run');
+        if (runIndex === 1 || runIndex === tokens.length - 1) {
+            return { valid: false, error: 'Malformed execute run clause' };
+        }
+        if (runIndex !== -1) {
+            const chainResult = this.validateAgainstTree(tokens.slice(0, runIndex));
+            if (!chainResult.valid) {
+                return chainResult;
+            }
+            return this.validate(tokens.slice(runIndex + 1).join(' '));
+        }
+        return this.validateAgainstTree(tokens);
+    }
+    validateScoreboard(tokens) {
+        if (tokens[1] === 'objectives' && tokens[2] === 'add') {
+            if (tokens.length < 5) {
+                return { valid: false, error: 'scoreboard objectives add requires name and criteria' };
+            }
+            return this.validateAgainstTree(tokens);
+        }
+        if (tokens[1] !== 'players' || !SCOREBOARD_PLAYER_ACTIONS.has(tokens[2] ?? '')) {
+            return this.validateAgainstTree(tokens);
+        }
+        const action = tokens[2];
+        if (action === 'enable') {
+            if (tokens.length !== 5) {
+                return { valid: false, error: 'scoreboard players enable requires target and objective' };
+            }
+            return this.validateAgainstTree(tokens);
+        }
+        if (action === 'get') {
+            if (tokens.length !== 5) {
+                return { valid: false, error: 'scoreboard players get requires target and objective' };
+            }
+            return this.validateAgainstTree(tokens);
+        }
+        if (action === 'operation') {
+            if (tokens.length !== 8) {
+                return { valid: false, error: 'scoreboard players operation requires 5 operands' };
+            }
+            if (!SCOREBOARD_OPERATIONS.has(tokens[5])) {
+                return { valid: false, error: `Unknown scoreboard operation: ${tokens[5]}` };
+            }
+            return this.validateAgainstTree(tokens);
+        }
+        if (tokens.length !== 6) {
+            return { valid: false, error: `scoreboard players ${action} requires target, objective, and value` };
+        }
+        if (!INTEGER_RE.test(tokens[5])) {
+            return { valid: false, error: `Expected integer value, got: ${tokens[5]}` };
+        }
+        return this.validateAgainstTree(tokens);
+    }
+    validateFunction(tokens) {
+        if (tokens.length !== 2 || !FUNCTION_ID_RE.test(tokens[1])) {
+            return { valid: false, error: 'function requires a namespaced function id' };
+        }
+        return this.validateAgainstTree(tokens);
+    }
+    validateData(tokens) {
+        if (tokens.length < 5) {
+            return { valid: false, error: 'data command is incomplete' };
+        }
+        const action = tokens[1];
+        if (!['get', 'modify', 'merge', 'remove'].includes(action)) {
+            return this.validateAgainstTree(tokens);
+        }
+        const targetType = tokens[2];
+        if (!['storage', 'entity', 'block'].includes(targetType)) {
+            return { valid: false, error: `Unsupported data target: ${targetType}` };
+        }
+        if (action === 'get') {
+            if (tokens.length < 5) {
+                return { valid: false, error: 'data get requires target and path' };
+            }
+            if (tokens[5] && !isNumberish(tokens[5])) {
+                return { valid: false, error: `Invalid data get scale: ${tokens[5]}` };
+            }
+            return this.validateAgainstTree(tokens);
+        }
+        if (action === 'modify') {
+            if (tokens.length < 7) {
+                return { valid: false, error: 'data modify is incomplete' };
+            }
+            if (!['set', 'append', 'prepend', 'insert', 'merge'].includes(tokens[5])) {
+                return { valid: false, error: `Unsupported data modify mode: ${tokens[5]}` };
+            }
+            return this.validateAgainstTree(tokens);
+        }
+        return this.validateAgainstTree(tokens);
+    }
+    validateReturn(tokens) {
+        if (tokens.length < 2) {
+            return { valid: false, error: 'return requires a value or run clause' };
+        }
+        if (tokens[1] === 'run') {
+            if (tokens.length < 3) {
+                return { valid: false, error: 'return run requires an inner command' };
+            }
+            return this.validate(tokens.slice(2).join(' '));
+        }
+        if (!INTEGER_RE.test(tokens[1])) {
+            return { valid: false, error: `Invalid return value: ${tokens[1]}` };
+        }
+        return this.validateAgainstTree(tokens);
+    }
+    validateAgainstTree(tokens) {
+        const memo = new Map();
+        const isValid = walk(this.root, tokens, 0, memo, this.rootChildren);
+        return isValid
+            ? { valid: true }
+            : { valid: false, error: `Command does not match Brigadier tree: ${tokens.join(' ')}` };
+    }
+}
+exports.MCCommandValidator = MCCommandValidator;
+function walk(node, tokens, index, memo, rootChildren) {
+    const key = `${node.name ?? '<root>'}:${index}`;
+    const cached = memo.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    if (index === tokens.length) {
+        const done = node.executable === true || (node.children ?? []).length === 0;
+        memo.set(key, done);
+        return done;
+    }
+    const children = node.children ?? [];
+    for (const child of children) {
+        if (child.type === 'literal') {
+            if (child.name === tokens[index] && walk(child, tokens, index + 1, memo, rootChildren)) {
+                memo.set(key, true);
+                return true;
+            }
+            continue;
+        }
+        if (child.type !== 'argument') {
+            continue;
+        }
+        const parser = child.parser?.parser;
+        const modifier = child.parser?.modifier?.type;
+        if (parserConsumesRest(parser, modifier)) {
+            const done = child.executable === true || (child.children ?? []).length === 0;
+            if (done) {
+                memo.set(key, true);
+                return true;
+            }
+        }
+        const width = parserTokenWidth(parser, tokens, index);
+        if (width === null) {
+            continue;
+        }
+        const nextIndex = index + width;
+        if (walk(child, tokens, nextIndex, memo, rootChildren)) {
+            memo.set(key, true);
+            return true;
+        }
+        for (const redirect of child.redirects ?? []) {
+            const target = rootChildren.find(candidate => candidate.name === redirect);
+            if (target && walk(target, tokens, nextIndex, memo, rootChildren)) {
+                memo.set(key, true);
+                return true;
+            }
+        }
+    }
+    memo.set(key, false);
+    return false;
+}
+function parserConsumesRest(parser, modifier) {
+    return ((parser === 'brigadier:string' && modifier === 'greedy') ||
+        parser === 'minecraft:message');
+}
+function parserTokenWidth(parser, tokens, index) {
+    switch (parser) {
+        case 'minecraft:vec3':
+        case 'minecraft:block_pos':
+            return index + 3 <= tokens.length ? 3 : null;
+        case 'minecraft:vec2':
+        case 'minecraft:column_pos':
+        case 'minecraft:rotation':
+            return index + 2 <= tokens.length ? 2 : null;
+        default:
+            return index < tokens.length ? 1 : null;
+    }
+}
+function tokenize(line) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    let escape = false;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    for (const char of line) {
+        if (escape) {
+            current += char;
+            escape = false;
+            continue;
+        }
+        if (quote) {
+            current += char;
+            if (char === '\\') {
+                escape = true;
+            }
+            else if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === '\'') {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (char === '[')
+            bracketDepth += 1;
+        if (char === ']')
+            bracketDepth = Math.max(0, bracketDepth - 1);
+        if (char === '{')
+            braceDepth += 1;
+        if (char === '}')
+            braceDepth = Math.max(0, braceDepth - 1);
+        if (/\s/.test(char) && bracketDepth === 0 && braceDepth === 0) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function isNumberish(value) {
+    return /^-?\d+(\.\d+)?$/.test(value) || SCORE_RANGE_RE.test(value);
+}
+//# sourceMappingURL=index.js.map

package/dist/src/nbt/index.d.ts

@@ -0,0 +1,86 @@
+export declare const enum TagType {
+    End = 0,
+    Byte = 1,
+    Short = 2,
+    Int = 3,
+    Long = 4,
+    Float = 5,
+    Double = 6,
+    ByteArray = 7,
+    String = 8,
+    List = 9,
+    Compound = 10,
+    IntArray = 11,
+    LongArray = 12
+}
+export type EndTag = {
+    type: TagType.End;
+};
+export type ByteTag = {
+    type: TagType.Byte;
+    value: number;
+};
+export type ShortTag = {
+    type: TagType.Short;
+    value: number;
+};
+export type IntTag = {
+    type: TagType.Int;
+    value: number;
+};
+export type LongTag = {
+    type: TagType.Long;
+    value: bigint;
+};
+export type FloatTag = {
+    type: TagType.Float;
+    value: number;
+};
+export type DoubleTag = {
+    type: TagType.Double;
+    value: number;
+};
+export type ByteArrayTag = {
+    type: TagType.ByteArray;
+    value: Int8Array;
+};
+export type StringTag = {
+    type: TagType.String;
+    value: string;
+};
+export type ListTag = {
+    type: TagType.List;
+    elementType: TagType;
+    items: NbtTag[];
+};
+export type CompoundTag = {
+    type: TagType.Compound;
+    entries: Map<string, NbtTag>;
+};
+export type IntArrayTag = {
+    type: TagType.IntArray;
+    value: Int32Array;
+};
+export type LongArrayTag = {
+    type: TagType.LongArray;
+    value: BigInt64Array;
+};
+export type NbtTag = EndTag | ByteTag | ShortTag | IntTag | LongTag | FloatTag | DoubleTag | ByteArrayTag | StringTag | ListTag | CompoundTag | IntArrayTag | LongArrayTag;
+export declare function writeNbt(tag: NbtTag, name: string): Buffer;
+export declare function readNbt(buffer: Buffer): {
+    name: string;
+    tag: NbtTag;
+};
+export declare const nbt: {
+    byte: (value: number) => ByteTag;
+    short: (value: number) => ShortTag;
+    int: (value: number) => IntTag;
+    long: (value: bigint) => LongTag;
+    float: (value: number) => FloatTag;
+    double: (value: number) => DoubleTag;
+    string: (value: string) => StringTag;
+    list: (elementType: TagType, items: NbtTag[]) => ListTag;
+    compound: (entries: Record<string, NbtTag>) => CompoundTag;
+    intArray: (values: number[]) => IntArrayTag;
+    byteArray: (values: number[]) => ByteArrayTag;
+};

package/dist/src/nbt/index.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nbt = void 0;
+exports.writeNbt = writeNbt;
+exports.readNbt = readNbt;
+function encodeModifiedUtf8(value) {
+    const bytes = [];
+    for (let i = 0; i < value.length; i++) {
+        const codeUnit = value.charCodeAt(i);
+        if (codeUnit !== 0 && codeUnit <= 0x7f) {
+            bytes.push(codeUnit);
+            continue;
+        }
+        if (codeUnit <= 0x07ff) {
+            bytes.push(0xc0 | ((codeUnit >> 6) & 0x1f), 0x80 | (codeUnit & 0x3f));
+            continue;
+        }
+        bytes.push(0xe0 | ((codeUnit >> 12) & 0x0f), 0x80 | ((codeUnit >> 6) & 0x3f), 0x80 | (codeUnit & 0x3f));
+    }
+    if (bytes.length > 0xffff) {
+        throw new Error(`NBT string is too long: ${bytes.length} bytes`);
+    }
+    const buffer = Buffer.allocUnsafe(2 + bytes.length);
+    buffer.writeUInt16BE(bytes.length, 0);
+    for (let i = 0; i < bytes.length; i++) {
+        buffer[2 + i] = bytes[i];
+    }
+    return buffer;
+}
+function decodeModifiedUtf8(buffer, offset) {
+    const byteLength = buffer.readUInt16BE(offset);
+    offset += 2;
+    const codeUnits = [];
+    const end = offset + byteLength;
+    while (offset < end) {
+        const first = buffer[offset++];
+        if ((first & 0x80) === 0) {
+            codeUnits.push(first);
+            continue;
+        }
+        if ((first & 0xe0) === 0xc0) {
+            const second = buffer[offset++];
+            codeUnits.push(((first & 0x1f) << 6) | (second & 0x3f));
+            continue;
+        }
+        const second = buffer[offset++];
+        const third = buffer[offset++];
+        codeUnits.push(((first & 0x0f) << 12) |
+            ((second & 0x3f) << 6) |
+            (third & 0x3f));
+    }
+    return {
+        value: String.fromCharCode(...codeUnits),
+        offset,
+    };
+}
+function writePayload(tag) {
+    switch (tag.type) {
+        case 0 /* TagType.End */:
+            return Buffer.alloc(0);
+        case 1 /* TagType.Byte */: {
+            const buffer = Buffer.allocUnsafe(1);
+            buffer.writeInt8(tag.value, 0);
+            return buffer;
+        }
+        case 2 /* TagType.Short */: {
+            const buffer = Buffer.allocUnsafe(2);
+            buffer.writeInt16BE(tag.value, 0);
+            return buffer;
+        }
+        case 3 /* TagType.Int */: {
+            const buffer = Buffer.allocUnsafe(4);
+            buffer.writeInt32BE(tag.value, 0);
+            return buffer;
+        }
+        case 4 /* TagType.Long */: {
+            const buffer = Buffer.allocUnsafe(8);
+            buffer.writeBigInt64BE(tag.value, 0);
+            return buffer;
+        }
+        case 5 /* TagType.Float */: {
+            const buffer = Buffer.allocUnsafe(4);
+            buffer.writeFloatBE(tag.value, 0);
+            return buffer;
+        }
+        case 6 /* TagType.Double */: {
+            const buffer = Buffer.allocUnsafe(8);
+            buffer.writeDoubleBE(tag.value, 0);
+            return buffer;
+        }
+        case 7 /* TagType.ByteArray */: {
+            const header = Buffer.allocUnsafe(4);
+            header.writeInt32BE(tag.value.length, 0);
+            return Buffer.concat([header, Buffer.from(tag.value)]);
+        }
+        case 8 /* TagType.String */:
+            return encodeModifiedUtf8(tag.value);
+        case 9 /* TagType.List */: {
+            const header = Buffer.allocUnsafe(5);
+            header.writeUInt8(tag.elementType, 0);
+            header.writeInt32BE(tag.items.length, 1);
+            return Buffer.concat([header, ...tag.items.map(writePayload)]);
+        }
+        case 10 /* TagType.Compound */: {
+            const parts = [];
+            for (const [name, entry] of tag.entries) {
+                parts.push(writeNamedTag(entry, name));
+            }
+            parts.push(Buffer.from([0 /* TagType.End */]));
+            return Buffer.concat(parts);
+        }
+        case 11 /* TagType.IntArray */: {
+            const header = Buffer.allocUnsafe(4 + tag.value.length * 4);
+            header.writeInt32BE(tag.value.length, 0);
+            for (let i = 0; i < tag.value.length; i++) {
+                header.writeInt32BE(tag.value[i], 4 + i * 4);
+            }
+            return header;
+        }
+        case 12 /* TagType.LongArray */: {
+            const header = Buffer.allocUnsafe(4 + tag.value.length * 8);
+            header.writeInt32BE(tag.value.length, 0);
+            for (let i = 0; i < tag.value.length; i++) {
+                header.writeBigInt64BE(tag.value[i], 4 + i * 8);
+            }
+            return header;
+        }
+    }
+}
+function writeNamedTag(tag, name) {
+    if (tag.type === 0 /* TagType.End */) {
+        throw new Error('TAG_End cannot be written as a named tag');
+    }
+    const nameBuffer = encodeModifiedUtf8(name);
+    return Buffer.concat([
+        Buffer.from([tag.type]),
+        nameBuffer,
+        writePayload(tag),
+    ]);
+}
+function readPayload(type, buffer, offset) {
+    switch (type) {
+        case 0 /* TagType.End */:
+            return { tag: { type: 0 /* TagType.End */ }, offset };
+        case 1 /* TagType.Byte */:
+            return { tag: { type: type, value: buffer.readInt8(offset) }, offset: offset + 1 };
+        case 2 /* TagType.Short */:
+            return { tag: { type: type, value: buffer.readInt16BE(offset) }, offset: offset + 2 };
+        case 3 /* TagType.Int */:
+            return { tag: { type: type, value: buffer.readInt32BE(offset) }, offset: offset + 4 };
+        case 4 /* TagType.Long */:
+            return { tag: { type: type, value: buffer.readBigInt64BE(offset) }, offset: offset + 8 };
+        case 5 /* TagType.Float */:
+            return { tag: { type: type, value: buffer.readFloatBE(offset) }, offset: offset + 4 };
+        case 6 /* TagType.Double */:
+            return { tag: { type: type, value: buffer.readDoubleBE(offset) }, offset: offset + 8 };
+        case 7 /* TagType.ByteArray */: {
+            const length = buffer.readInt32BE(offset);
+            offset += 4;
+            const value = new Int8Array(length);
+            for (let i = 0; i < length; i++) {
+                value[i] = buffer.readInt8(offset + i);
+            }
+            return { tag: { type, value }, offset: offset + length };
+        }
+        case 8 /* TagType.String */: {
+            const decoded = decodeModifiedUtf8(buffer, offset);
+            return { tag: { type, value: decoded.value }, offset: decoded.offset };
+        }
+        case 9 /* TagType.List */: {
+            const elementType = buffer.readUInt8(offset);
+            const length = buffer.readInt32BE(offset + 1);
+            offset += 5;
+            const items = [];
+            for (let i = 0; i < length; i++) {
+                const parsed = readPayload(elementType, buffer, offset);
+                items.push(parsed.tag);
+                offset = parsed.offset;
+            }
+            return { tag: { type, elementType, items }, offset };
+        }
+        case 10 /* TagType.Compound */: {
+            const entries = new Map();
+            while (true) {
+                const entryType = buffer.readUInt8(offset);
+                offset += 1;
+                if (entryType === 0 /* TagType.End */)
+                    break;
+                const name = decodeModifiedUtf8(buffer, offset);
+                offset = name.offset;
+                const parsed = readPayload(entryType, buffer, offset);
+                entries.set(name.value, parsed.tag);
+                offset = parsed.offset;
+            }
+            return { tag: { type, entries }, offset };
+        }
+        case 11 /* TagType.IntArray */: {
+            const length = buffer.readInt32BE(offset);
+            offset += 4;
+            const value = new Int32Array(length);
+            for (let i = 0; i < length; i++) {
+                value[i] = buffer.readInt32BE(offset + i * 4);
+            }
+            return { tag: { type, value }, offset: offset + length * 4 };
+        }
+        case 12 /* TagType.LongArray */: {
+            const length = buffer.readInt32BE(offset);
+            offset += 4;
+            const value = new BigInt64Array(length);
+            for (let i = 0; i < length; i++) {
+                value[i] = buffer.readBigInt64BE(offset + i * 8);
+            }
+            return { tag: { type, value }, offset: offset + length * 8 };
+        }
+        default:
+            throw new Error(`Unsupported NBT tag type: ${type}`);
+    }
+}
+function writeNbt(tag, name) {
+    return writeNamedTag(tag, name);
+}
+function readNbt(buffer) {
+    let offset = 0;
+    const type = buffer.readUInt8(offset);
+    offset += 1;
+    if (type === 0 /* TagType.End */) {
+        throw new Error('Invalid root tag: TAG_End');
+    }
+    const decodedName = decodeModifiedUtf8(buffer, offset);
+    offset = decodedName.offset;
+    const parsed = readPayload(type, buffer, offset);
+    return {
+        name: decodedName.value,
+        tag: parsed.tag,
+    };
+}
+exports.nbt = {
+    byte: (value) => ({ type: 1 /* TagType.Byte */, value }),
+    short: (value) => ({ type: 2 /* TagType.Short */, value }),
+    int: (value) => ({ type: 3 /* TagType.Int */, value }),
+    long: (value) => ({ type: 4 /* TagType.Long */, value }),
+    float: (value) => ({ type: 5 /* TagType.Float */, value }),
+    double: (value) => ({ type: 6 /* TagType.Double */, value }),
+    string: (value) => ({ type: 8 /* TagType.String */, value }),
+    list: (elementType, items) => ({ type: 9 /* TagType.List */, elementType, items }),
+    compound: (entries) => ({ type: 10 /* TagType.Compound */, entries: new Map(Object.entries(entries)) }),
+    intArray: (values) => ({ type: 11 /* TagType.IntArray */, value: Int32Array.from(values) }),
+    byteArray: (values) => ({ type: 7 /* TagType.ByteArray */, value: Int8Array.from(values) }),
+};
+//# sourceMappingURL=index.js.map

package/dist/src/optimizer/commands.d.ts

@@ -0,0 +1,38 @@
+import type { IRCommand } from '../ir/types';
+export interface OptimizationStats {
+    licmHoists: number;
+    licmLoopBodies: number;
+    cseRedundantReads: number;
+    cseArithmetic: number;
+    setblockMergedCommands: number;
+    setblockFillCommands: number;
+    setblockSavedCommands: number;
+    deadCodeRemoved: number;
+    constantFolds: number;
+    inlinedTrivialFunctions: number;
+    totalCommandsBefore: number;
+    totalCommandsAfter: number;
+}
+export interface CommandFunction {
+    name: string;
+    commands: IRCommand[];
+}
+export declare function setOptimizerObjective(obj: string): void;
+export declare function createEmptyOptimizationStats(): OptimizationStats;
+export declare function mergeOptimizationStats(base: OptimizationStats, delta: Partial<OptimizationStats>): void;
+export declare function applyLICM(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function applyCSE(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function batchSetblocks(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function optimizeCommandFunctions(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};