redscript-mc 2.0.0 → 2.1.1

package/dist/mc-validator/index.js

@@ -1,322 +0,0 @@
-"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/mypack.map.json

@@ -1,27 +0,0 @@
-{
-  "$o": "x",
-  "$r": "execute",
-  "$u": "y",
-  "$aa": "ax",
-  "$ad": "ay",
-  "$ai": "swapped",
-  "$ak": "tmp",
-  "$al": "lo",
-  "$am": "hi",
-  "$ar": "mid",
-  "$as": "t",
-  "$ax": "theta",
-  "$a": "const:0",
-  "$b": "const:1",
-  "$c": "const:2",
-  "$d": "const:45",
-  "$e": "const:90",
-  "$f": "const:180",
-  "$g": "const:270",
-  "$h": "const:360",
-  "$i": "const:1000",
-  "$j": "const:46340",
-  "$k": "internal:ret",
-  "$n": "internal:p0",
-  "$t": "internal:p1"
-}

package/dist/nbt/index.d.ts

@@ -1,86 +0,0 @@
-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/nbt/index.js

@@ -1,250 +0,0 @@
-"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