@spyglassmc/java-edition 0.1.0

package/lib/mcfunction/parser/argument.js

@@ -0,0 +1,934 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.team = exports.tag = exports.scoreHolderFakeName = exports.component = exports.blockPredicate = exports.argument = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const core_1 = require("@spyglassmc/core");
+const json = __importStar(require("@spyglassmc/json"));
+const locales_1 = require("@spyglassmc/locales");
+const mcf = __importStar(require("@spyglassmc/mcfunction"));
+const nbt = __importStar(require("@spyglassmc/nbt"));
+const dependency_1 = require("../../dependency");
+const common_1 = require("../common");
+const node_1 = require("../node");
+const IntegerPattern = /^-?\d+$/;
+/**
+ * A combination of:
+ * - https://github.com/Mojang/brigadier/blob/cf754c4ef654160dca946889c11941634c5db3d5/src/main/java/com/mojang/brigadier/StringReader.java#L137
+ * - https://docs.oracle.com/javase/7/docs/api/java/lang/Double.html#valueOf(java.lang.String)
+ *
+ * i.e. Only `[0-9\.\-]` is allowed in the number, and its format must follow The Java™ Language Specification.
+ *
+ * i.e.
+ * ```
+ * [NegativeSign] Digits [`.`] [Digits] |
+ * [NegativeSign] `.` Digits
+ * ```
+ */
+const FloatPattern = /^-?(?:\d+\.?\d*|\.\d+)$/;
+const DoubleMax = Number.MAX_VALUE;
+const DoubleMin = -DoubleMax;
+const FloatMax = (2 - (2 ** -23)) * (2 ** 127);
+const FloatMin = -FloatMax;
+const IntegerMax = 2 ** 31 - 1;
+const IntegerMin = -(2 ** 31);
+const LongMax = 9223372036854775807n;
+const LongMin = -9223372036854775808n;
+const FakeNameMaxLength = 40;
+const ObjectiveMaxLength = 16;
+const PlayerNameMaxLength = 16;
+function shouldValidateLength(ctx) {
+    const major = ctx.project['loadedVersion'];
+    return !major || dependency_1.MajorVersion.cmp(major, '1.18') < 0;
+}
+/**
+ * @returns The parser for the specified argument tree node. All argument parsers used in the `mcfunction` package
+ * fail on empty input.
+ */
+const argument = (rawTreeNode) => {
+    const treeNode = rawTreeNode;
+    const wrap = (parser) => core.failOnEmpty(core.stopBefore(parser, '\r', '\n'));
+    switch (treeNode.parser) {
+        case 'brigadier:bool':
+            return wrap(core.boolean);
+        case 'brigadier:double':
+            return wrap(double(treeNode.properties?.min, treeNode.properties?.max));
+        case 'brigadier:float':
+            return wrap(float(treeNode.properties?.min, treeNode.properties?.max));
+        case 'brigadier:integer':
+            return wrap(integer(treeNode.properties?.min, treeNode.properties?.max));
+        case 'brigadier:long':
+            return wrap(long(treeNode.properties?.min, treeNode.properties?.max));
+        case 'brigadier:string':
+            switch (treeNode.properties.type) {
+                case 'word':
+                    return wrap(unquotedString);
+                case 'phrase':
+                    return wrap(core.brigadierString);
+                case 'greedy':
+                default:
+                    return wrap(greedyString);
+            }
+        case 'minecraft:angle':
+            return wrap(core.validate(coordinate(), res => res.notation !== '^', (0, locales_1.localize)('mcfunction.parser.vector.local-disallowed')));
+        case 'minecraft:block_pos':
+            return wrap(vector({ dimension: 3, integersOnly: true }));
+        case 'minecraft:block_predicate':
+            return wrap(exports.blockPredicate);
+        case 'minecraft:block_state':
+            return wrap(blockState);
+        case 'minecraft:color':
+            return wrap(core.map(core.literal(...common_1.ColorArgumentValues), res => ({
+                ...res,
+                color: core.Color.NamedColors.has(res.value)
+                    ? core.Color.fromCompositeInt(core.Color.NamedColors.get(res.value))
+                    : undefined,
+            })));
+        case 'minecraft:column_pos':
+            return wrap(vector({ dimension: 2, integersOnly: true }));
+        case 'minecraft:component':
+            return wrap(exports.component);
+        case 'minecraft:dimension':
+            return wrap(core.resourceLocation({
+                category: 'dimension',
+            }));
+        case 'minecraft:entity':
+            return wrap(entity(treeNode.properties.amount, treeNode.properties.type));
+        case 'minecraft:entity_anchor':
+            return wrap(core.literal(...common_1.EntityAnchorArgumentValues));
+        case 'minecraft:entity_summon':
+            return wrap(core.resourceLocation({
+                category: 'entity_type',
+            }));
+        case 'minecraft:float_range':
+            return wrap(range('float'));
+        case 'minecraft:function':
+            return wrap(core.resourceLocation({
+                category: 'function',
+                allowTag: true,
+            }));
+        case 'minecraft:game_profile':
+            return wrap(entity('multiple', 'players'));
+        case 'minecraft:int_range':
+            return wrap(range('integer'));
+        case 'minecraft:item_enchantment':
+            return wrap(core.resourceLocation({
+                category: 'enchantment',
+            }));
+        case 'minecraft:item_predicate':
+            return wrap(itemPredicate);
+        case 'minecraft:item_slot':
+            return wrap(core.literal(...common_1.ItemSlotArgumentValues));
+        case 'minecraft:item_stack':
+            return wrap(itemStack);
+        case 'minecraft:message':
+            return wrap(message);
+        case 'minecraft:mob_effect':
+            return wrap(core.resourceLocation({
+                category: 'mob_effect',
+            }));
+        case 'minecraft:nbt_compound_tag':
+            return wrap(nbt.parser.compound);
+        case 'minecraft:nbt_path':
+            return wrap(nbt.parser.path);
+        case 'minecraft:nbt_tag':
+            return wrap(nbt.parser.entry);
+        case 'minecraft:objective':
+            return wrap(objective(core.SymbolUsageType.is(treeNode.properties?.usageType)
+                ? treeNode.properties?.usageType
+                : undefined));
+        case 'minecraft:objective_criteria':
+            return wrap(objectiveCriteria);
+        case 'minecraft:operation':
+            return wrap(core.literal({
+                pool: common_1.OperationArgumentValues,
+                colorTokenType: 'operator',
+            }));
+        case 'minecraft:particle':
+            return wrap(particle);
+        case 'minecraft:resource':
+        case 'minecraft:resource_or_tag':
+            return wrap(core.resourceLocation({
+                category: core.ResourceLocation.shorten(treeNode.properties.registry),
+                allowTag: treeNode.parser === 'minecraft:resource_or_tag',
+            }));
+        case 'minecraft:resource_location':
+            return wrap(core.resourceLocation(treeNode.properties ?? {
+                pool: [],
+                allowUnknown: true,
+            }));
+        case 'minecraft:rotation':
+            return wrap(vector({ dimension: 2, noLocal: true }));
+        case 'minecraft:score_holder':
+            return wrap(scoreHolder(treeNode.properties.amount));
+        case 'minecraft:scoreboard_slot':
+            // `BELOWNAME` and `sidebar.team.r--.+++e----__d` are also legal slots.
+            // But I do not want to spend time supporting them.
+            return wrap(core.literal(...common_1.ScoreboardSlotArgumentValues));
+        case 'minecraft:swizzle':
+            return wrap(core.literal(...common_1.SwizzleArgumentValues));
+        case 'minecraft:team':
+            return wrap(team(core.SymbolUsageType.is(treeNode.properties?.usageType)
+                ? treeNode.properties?.usageType
+                : undefined));
+        case 'minecraft:time':
+            return wrap(time);
+        case 'minecraft:uuid':
+            return wrap(uuid);
+        case 'minecraft:vec2':
+            return wrap(vector({ dimension: 2, noLocal: true }));
+        case 'minecraft:vec3':
+            return wrap(vector({ dimension: 3 }));
+        case 'spyglassmc:tag':
+            return wrap(tag());
+        default:
+            // Unknown parser.
+            return undefined;
+    }
+};
+exports.argument = argument;
+function block(isPredicate) {
+    return core.map(core.sequence([
+        core.resourceLocation({ category: 'block', allowTag: isPredicate }),
+        core.optional(core.map(core.failOnEmpty(core.record({
+            start: '[',
+            pair: {
+                key: core.string({
+                    ...core.BrigadierStringOptions,
+                    colorTokenType: 'property',
+                }),
+                sep: '=',
+                value: core.brigadierString,
+                end: ',',
+                trailingEnd: true,
+            },
+            end: ']',
+        })), res => ({
+            ...res,
+            type: 'mcfunction:block/states',
+        }))),
+        core.optional(core.failOnEmpty(nbt.parser.compound)),
+    ]), res => {
+        const ans = {
+            type: 'mcfunction:block',
+            range: res.range,
+            children: res.children,
+            id: res.children.find(core.ResourceLocationNode.is),
+            states: res.children.find(node_1.BlockStatesNode.is),
+            nbt: res.children.find(nbt.NbtCompoundNode.is),
+        };
+        return ans;
+    });
+}
+const blockState = block(false);
+exports.blockPredicate = block(true);
+exports.component = json.parser.json();
+function double(min = DoubleMin, max = DoubleMax) {
+    return core.float({
+        pattern: FloatPattern,
+        min,
+        max,
+    });
+}
+function float(min = FloatMin, max = FloatMax) {
+    return core.float({
+        pattern: FloatPattern,
+        min,
+        max,
+    });
+}
+function integer(min = IntegerMin, max = IntegerMax) {
+    return core.integer({
+        pattern: IntegerPattern,
+        min,
+        max,
+    });
+}
+function long(min, max) {
+    return core.long({
+        pattern: IntegerPattern,
+        min: BigInt(min ?? LongMin),
+        max: BigInt(max ?? LongMax),
+    });
+}
+function coordinate(integerOnly = false) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'mcfunction:coordinate',
+            notation: '',
+            range: core.Range.create(src),
+            value: 0,
+        };
+        if (src.trySkip('^')) {
+            ans.notation = '^';
+        }
+        else if (src.trySkip('~')) {
+            ans.notation = '~';
+        }
+        if ((src.canReadInLine() && src.peek() !== ' ') || ans.notation === '') {
+            const result = (integerOnly && ans.notation === '' ? integer : double)()(src, ctx);
+            ans.value = Number(result.value);
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+function entity(amount, type) {
+    return core.map(core.select([
+        {
+            predicate: src => node_1.EntitySelectorAtVariable.is(src.peek(2)),
+            parser: selector(),
+        },
+        {
+            parser: core.any([
+                validateLength(core.brigadierString, PlayerNameMaxLength, 'mcfunction.parser.entity-selector.player-name.too-long'),
+                uuid,
+            ]),
+        },
+    ]), (res, _src, ctx) => {
+        const ans = {
+            type: 'mcfunction:entity',
+            range: res.range,
+            children: [res],
+        };
+        if (core.StringNode.is(res)) {
+            ans.playerName = res;
+        }
+        else if (node_1.EntitySelectorNode.is(res)) {
+            ans.selector = res;
+        }
+        else {
+            ans.uuid = res;
+        }
+        if (amount === 'single' && ans.selector && !ans.selector.single) {
+            ctx.err.report((0, locales_1.localize)('mcfunction.parser.entity-selector.multiple-disallowed'), ans);
+        }
+        if (type === 'players' && (ans.uuid || (ans.selector && !ans.selector.playersOnly && !ans.selector.currentEntity))) {
+            ctx.err.report((0, locales_1.localize)('mcfunction.parser.entity-selector.entities-disallowed'), ans);
+        }
+        return ans;
+    });
+}
+const greedyString = core.string({
+    unquotable: { blockList: new Set(['\n', '\r']) },
+});
+function item(isPredicate) {
+    return core.map(core.sequence([
+        core.resourceLocation({ category: 'item', allowTag: isPredicate }),
+        core.optional(core.failOnEmpty(nbt.parser.compound)),
+    ]), res => {
+        const ans = {
+            type: 'mcfunction:item',
+            range: res.range,
+            children: res.children,
+            id: res.children.find(core.ResourceLocationNode.is),
+            nbt: res.children.find(nbt.NbtCompoundNode.is),
+        };
+        return ans;
+    });
+}
+const itemStack = item(false);
+const itemPredicate = item(true);
+const message = (src, ctx) => {
+    const ans = {
+        type: 'mcfunction:message',
+        range: core.Range.create(src),
+        children: [],
+    };
+    while (src.canReadInLine()) {
+        if (node_1.EntitySelectorAtVariable.is(src.peek(2))) {
+            ans.children.push(selector()(src, ctx));
+        }
+        else {
+            ans.children.push(core.stopBefore(greedyString, ...node_1.EntitySelectorAtVariables)(src, ctx));
+        }
+    }
+    return ans;
+};
+const particle = (() => {
+    const sep = core.map(mcf.sep, () => []);
+    const vec = vector({ dimension: 3 });
+    const color = core.map(vec, res => ({
+        ...res,
+        color: res.children.length === 3
+            ? {
+                value: core.Color.fromDecRGB(res.children[0].value, res.children[1].value, res.children[2].value),
+                format: [core.ColorFormat.DecRGB],
+            }
+            : undefined,
+    }));
+    const map = {
+        block: blockState,
+        block_marker: blockState,
+        dust: (0, core_1.sequence)([color, float()], sep),
+        dust_color_transition: (0, core_1.sequence)([color, float(), color], sep),
+        falling_dust: blockState,
+        item: itemStack,
+        sculk_charge: float(),
+        vibration: (0, core_1.sequence)([vec, vec, integer()], sep),
+    };
+    return core.map((0, core_1.sequence)([
+        core.resourceLocation({ category: 'particle_type' }),
+        {
+            get: res => {
+                return map[core.ResourceLocationNode.toString(res.children[0], 'short')];
+            },
+        },
+    ], sep), res => {
+        const ans = {
+            type: 'mcfunction:particle',
+            range: res.range,
+            children: res.children,
+            id: res.children.find(core.ResourceLocationNode.is),
+        };
+        return ans;
+    });
+})();
+function range(type, min, max, cycleable) {
+    const number = type === 'float' ? float(min, max) : integer(min, max);
+    const low = core.failOnEmpty(core.stopBefore(number, '..'));
+    const sep = core.failOnEmpty(core.literal({ pool: ['..'], colorTokenType: 'keyword' }));
+    const high = core.failOnEmpty(number);
+    return core.map(core.any([
+        /* exactly */ core.sequence([low]),
+        /* atLeast */ core.sequence([low, sep]),
+        /* atMost  */ core.sequence([sep, high]),
+        /* between */ core.sequence([low, sep, high]),
+    ]), (res, _src, ctx) => {
+        const valueNodes = type === 'float'
+            ? res.children.filter(core.FloatNode.is)
+            : res.children.filter(core.IntegerNode.is);
+        const sepNode = res.children.find(core.LiteralNode.is);
+        const ans = {
+            type: type === 'float' ? 'mcfunction:float_range' : 'mcfunction:int_range',
+            range: res.range,
+            children: res.children,
+            value: sepNode
+                ? valueNodes.length === 2
+                    ? [valueNodes[0].value, valueNodes[1].value]
+                    : core.Range.endsBefore(valueNodes[0].range, sepNode.range.start)
+                        ? [valueNodes[0].value, undefined]
+                        : [undefined, valueNodes[0].value]
+                : [valueNodes[0].value, valueNodes[0].value],
+        };
+        if (!cycleable && ans.value[0] !== undefined && ans.value[1] !== undefined && ans.value[0] > ans.value[1]) {
+            ctx.err.report((0, locales_1.localize)('mcfunction.parser.range.min>max', ans.value[0], ans.value[1]), res);
+        }
+        return ans;
+    });
+}
+/**
+ * Failure when not beginning with `@[parse]`
+ */
+function selector() {
+    let chunkLimited;
+    let currentEntity;
+    let dimensionLimited;
+    let playersOnly;
+    let predicates;
+    let single;
+    let typeLimited;
+    return core.map(core.sequence([
+        core.failOnEmpty(core.literal({ pool: node_1.EntitySelectorAtVariables, colorTokenType: 'keyword' })),
+        {
+            get: res => {
+                const variable = core.LiteralNode.is(res.children?.[0]) ? res.children[0].value : undefined;
+                currentEntity = variable ? variable === '@s' : undefined;
+                playersOnly = variable ? variable === '@p' || variable === '@a' || variable === '@r' : undefined;
+                predicates = variable === '@e' ? ['Entity::isAlive'] : undefined;
+                single = variable ? variable === '@p' || variable === '@r' || variable === '@s' : undefined;
+                typeLimited = playersOnly;
+                function invertable(parser) {
+                    return core.map(core.sequence([
+                        core.optional(core.failOnEmpty(core.literal({ pool: ['!'], colorTokenType: 'keyword' }))),
+                        src => { src.skipSpace(); return undefined; },
+                        parser,
+                    ]), res => {
+                        const ans = {
+                            type: 'mcfunction:entity_selector/arguments/value/invertable',
+                            range: res.range,
+                            children: res.children,
+                            inverted: !!res.children.find(n => core.LiteralNode.is(n) && n.value === '!'),
+                            value: res.children.find(n => !core.LiteralNode.is(n) || n.value !== '!'),
+                        };
+                        return ans;
+                    });
+                }
+                return core.optional(core.map(core.failOnEmpty(core.record({
+                    start: '[',
+                    pair: {
+                        key: core.string({
+                            ...core.BrigadierStringOptions,
+                            value: {
+                                parser: core.literal({ pool: [...node_1.EntitySelectorNode.ArgumentKeys], colorTokenType: 'property' }),
+                                type: 'literal',
+                            },
+                        }),
+                        sep: '=',
+                        value: {
+                            get: (record, key) => {
+                                const hasKey = (key) => !!record.children.find(p => p.key?.value === key);
+                                const hasNonInvertedKey = (key) => !!record.children.find(p => p.key?.value === key && !p.value?.inverted);
+                                switch (key?.value) {
+                                    case 'advancements':
+                                        return core.map(core.record({
+                                            start: '{',
+                                            pair: {
+                                                key: core.resourceLocation({ category: 'advancement' }),
+                                                sep: '=',
+                                                value: core.select([
+                                                    {
+                                                        predicate: src => src.peek() === '{',
+                                                        parser: core.map(core.record({
+                                                            start: '{',
+                                                            pair: {
+                                                                key: unquotedString,
+                                                                sep: '=',
+                                                                value: core.boolean,
+                                                                end: ',',
+                                                                trailingEnd: true,
+                                                            },
+                                                            end: '}',
+                                                        }), res => {
+                                                            const ans = {
+                                                                ...res,
+                                                                type: 'mcfunction:entity_selector/arguments/advancements/criteria',
+                                                            };
+                                                            return ans;
+                                                        }),
+                                                    },
+                                                    {
+                                                        parser: core.boolean,
+                                                    },
+                                                ]),
+                                                end: ',',
+                                                trailingEnd: true,
+                                            },
+                                            end: '}',
+                                        }), (res, _, ctx) => {
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            const ans = {
+                                                ...res,
+                                                type: 'mcfunction:entity_selector/arguments/advancements',
+                                            };
+                                            return ans;
+                                        });
+                                    case 'distance':
+                                        return core.map(range('float', 0), (res, _, ctx) => {
+                                            dimensionLimited = true;
+                                            // x, y, z, dx, dy, dz take precedence over distance, so we use ??= instead of = to ensure it won't override the result.
+                                            chunkLimited ?? (chunkLimited = !playersOnly && res.value[1] !== undefined);
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'gamemode':
+                                        return core.map(invertable(core.string({
+                                            unquotable: core.BrigadierUnquotableOption,
+                                            value: {
+                                                type: 'literal',
+                                                parser: core.literal('adventure', 'creative', 'spectator', 'survival'),
+                                            },
+                                        })), (res, _, ctx) => {
+                                            playersOnly = true;
+                                            if (res.inverted ? hasNonInvertedKey(key.value) : hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'limit':
+                                        return core.map(integer(0), (res, _, ctx) => {
+                                            single = res.value <= 1;
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            if (currentEntity) {
+                                                ctx.err.report((0, locales_1.localize)('mcfunction.parser.entity-selector.arguments.not-applicable', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'level':
+                                        return core.map(range('integer', 0), (res, _, ctx) => {
+                                            playersOnly = true;
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'name':
+                                        return core.map(invertable(core.brigadierString), (res, _, ctx) => {
+                                            if (res.inverted ? hasNonInvertedKey(key.value) : hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'nbt':
+                                        return invertable(nbt.parser.compound);
+                                    case 'predicate':
+                                        return invertable(core.resourceLocation({ category: 'predicate' }));
+                                    case 'scores':
+                                        return core.map(core.record({
+                                            start: '{',
+                                            pair: {
+                                                key: objective('reference', ['[', '=', ',', ']', '{', '}']),
+                                                sep: '=',
+                                                value: range('integer'),
+                                                end: ',',
+                                                trailingEnd: true,
+                                            },
+                                            end: '}',
+                                        }), (res, _, ctx) => {
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            const ans = {
+                                                ...res,
+                                                type: 'mcfunction:entity_selector/arguments/scores',
+                                            };
+                                            return ans;
+                                        });
+                                    case 'sort':
+                                        return core.map(core.string({
+                                            unquotable: core.BrigadierUnquotableOption,
+                                            value: {
+                                                type: 'literal',
+                                                parser: core.literal('arbitrary', 'furthest', 'nearest', 'random'),
+                                            },
+                                        }), (res, _, ctx) => {
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            if (currentEntity) {
+                                                ctx.err.report((0, locales_1.localize)('mcfunction.parser.entity-selector.arguments.not-applicable', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'tag':
+                                        return invertable(tag(['[', '=', ',', ']', '{', '}']));
+                                    case 'team':
+                                        return core.map(invertable(team('reference', ['[', '=', ',', ']', '{', '}'])), (res, _, ctx) => {
+                                            if (res.inverted ? hasNonInvertedKey(key.value) : hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'type':
+                                        return core.map(invertable(core.resourceLocation({ category: 'entity_type', allowTag: true })), (res, _, ctx) => {
+                                            if (typeLimited) {
+                                                if (hasKey(key.value)) {
+                                                    ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                                }
+                                                else {
+                                                    ctx.err.report((0, locales_1.localize)('mcfunction.parser.entity-selector.arguments.not-applicable', (0, locales_1.localeQuote)(key.value)), key);
+                                                }
+                                            }
+                                            else if (!res.inverted && !res.value.isTag) {
+                                                typeLimited = true;
+                                                if (core.ResourceLocationNode.toString(res.value, 'short') === 'player') {
+                                                    playersOnly = true;
+                                                }
+                                            }
+                                            return res;
+                                        });
+                                    case 'x':
+                                    case 'y':
+                                    case 'z':
+                                        return core.map(double(), (res, _, ctx) => {
+                                            dimensionLimited = true;
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'dx':
+                                    case 'dy':
+                                    case 'dz':
+                                        return core.map(double(), (res, _, ctx) => {
+                                            dimensionLimited = true;
+                                            chunkLimited = !playersOnly;
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case 'x_rotation':
+                                    case 'y_rotation':
+                                        return core.map(range('float', undefined, undefined, true), (res, _, ctx) => {
+                                            if (hasKey(key.value)) {
+                                                ctx.err.report((0, locales_1.localize)('duplicate-key', (0, locales_1.localeQuote)(key.value)), key);
+                                            }
+                                            return res;
+                                        });
+                                    case undefined:
+                                        // The key is empty. Let's just fail the value as well.
+                                        return () => core.Failure;
+                                    default:
+                                        // The key is unknown.
+                                        return (_src, ctx) => {
+                                            ctx.err.report((0, locales_1.localize)('mcfunction.parser.entity-selector.arguments.unknown', (0, locales_1.localeQuote)(key.value)), key);
+                                            return core.Failure;
+                                        };
+                                }
+                            },
+                        },
+                        end: ',',
+                        trailingEnd: true,
+                    },
+                    end: ']',
+                })), res => {
+                    const ans = {
+                        ...res,
+                        type: 'mcfunction:entity_selector/arguments',
+                    };
+                    return ans;
+                }));
+            },
+        },
+    ]), res => {
+        const ans = {
+            type: 'mcfunction:entity_selector',
+            range: res.range,
+            children: res.children,
+            variable: res.children.find(core.LiteralNode.is).value.slice(1),
+            arguments: res.children.find(node_1.EntitySelectorArgumentsNode.is),
+            chunkLimited,
+            currentEntity,
+            dimensionLimited,
+            playersOnly,
+            predicates,
+            single,
+            typeLimited,
+        };
+        ans.hover = getEntitySelectorHover(ans);
+        return ans;
+    });
+}
+// This is more like a proof-of-concept.
+// Might not make into the actual release.
+function getEntitySelectorHover(node) {
+    const grades = new Map([
+        [0, '🤢'],
+        [1, '😅'],
+        [2, 'Good'],
+        [3, 'Great'],
+        [4, '😌👌'], // Excellent
+    ]);
+    let ans;
+    if (node.currentEntity) {
+        ans = `**Performance**: ${grades.get(4)}  
+- \`currentEntity\`: \`${node.currentEntity}\``;
+    }
+    else {
+        const amountOfTrue = [node.chunkLimited, node.dimensionLimited, node.playersOnly, node.typeLimited].filter(v => v).length;
+        ans = `**Performance**: ${grades.get(amountOfTrue)}  
+- \`chunkLimited\`: \`${!!node.chunkLimited}\`
+- \`dimensionLimited\`: \`${!!node.dimensionLimited}\`
+- \`playersOnly\`: \`${!!node.playersOnly}\`
+- \`typeLimited\`: \`${!!node.chunkLimited}\``;
+    }
+    if (node.predicates?.length) {
+        ans += `
+
+------
+**Predicates**: 
+${node.predicates.map(p => `- \`${p}\``).join('\n')}`;
+    }
+    return ans;
+}
+exports.scoreHolderFakeName = validateLength(symbol('score_holder'), FakeNameMaxLength, 'mcfunction.parser.score_holder.fake-name.too-long');
+function scoreHolder(amount) {
+    return core.map(core.select([
+        {
+            predicate: src => node_1.EntitySelectorAtVariable.is(src.peek(2)),
+            parser: selector(),
+        },
+        {
+            parser: exports.scoreHolderFakeName,
+        },
+    ]), (res, _src, ctx) => {
+        const ans = {
+            type: 'mcfunction:score_holder',
+            range: res.range,
+            children: [res],
+        };
+        if (core.SymbolNode.is(res)) {
+            ans.fakeName = res;
+        }
+        else {
+            ans.selector = res;
+        }
+        if (amount === 'single' && ans.selector && !ans.selector.single) {
+            ctx.err.report((0, locales_1.localize)('mcfunction.parser.entity-selector.multiple-disallowed'), ans);
+        }
+        return ans;
+    });
+}
+function symbol(options, terminators = []) {
+    return core.stopBefore(core.symbol(options), core.Whitespaces, terminators);
+}
+function objective(usageType, terminators = []) {
+    return validateLength(unquotableSymbol({ category: 'objective', usageType }, terminators), ObjectiveMaxLength, 'mcfunction.parser.objective.too-long');
+}
+const objectiveCriteria = core.map(core.any([
+    core.sequence([
+        core.stopBefore(core.resourceLocation({ category: 'stat_type', namespacePathSep: '.' }), ':'),
+        core.failOnEmpty(core.literal(':')),
+        {
+            get: res => {
+                if (core.ResourceLocationNode.is(res.children[0])) {
+                    const category = node_1.ObjectiveCriteriaNode.ComplexCategories.get(core.ResourceLocationNode.toString(res.children[0], 'short'));
+                    if (category) {
+                        return core.resourceLocation({ category, namespacePathSep: '.' });
+                    }
+                }
+                return core.resourceLocation({ pool: [], allowUnknown: true, namespacePathSep: '.' });
+            },
+        },
+    ]),
+    core.literal(...node_1.ObjectiveCriteriaNode.SimpleValues),
+]), res => {
+    const ans = {
+        type: 'mcfunction:objective_criteria',
+        range: res.range,
+    };
+    if (core.LiteralNode.is(res)) {
+        ans.simpleValue = res.value;
+    }
+    else {
+        ans.children = res.children.filter(core.ResourceLocationNode.is);
+    }
+    return ans;
+});
+function tag(terminators = []) {
+    return unquotableSymbol('tag', terminators);
+}
+exports.tag = tag;
+function team(usageType, terminators = []) {
+    return unquotableSymbol({ category: 'team', usageType }, terminators);
+}
+exports.team = team;
+function unquotableSymbol(options, terminators) {
+    return validateUnquotable(symbol(options, terminators));
+}
+const time = core.map(core.sequence([float(0, undefined), core.optional(core.failOnEmpty(core.literal(...node_1.TimeNode.Units)))]), res => {
+    const valueNode = res.children.find(core.FloatNode.is);
+    const unitNode = res.children.find(core.LiteralNode.is);
+    const ans = {
+        type: 'mcfunction:time',
+        range: res.range,
+        children: res.children,
+        value: valueNode.value,
+        unit: unitNode?.value,
+    };
+    return ans;
+});
+const unquotedString = core.string({
+    unquotable: core.BrigadierUnquotableOption,
+});
+const UuidPattern = /^[0-9a-f]+-[0-9a-f]+-[0-9a-f]+-[0-9a-f]+-[0-9a-f]+$/i;
+const uuid = (src, ctx) => {
+    const ans = {
+        type: 'mcfunction:uuid',
+        range: core.Range.create(src),
+        bits: [0n, 0n],
+    };
+    const raw = src.readUntil(' ', '\r', '\n', '\r');
+    /**
+     * According to the implementation of Minecraft's UUID parser and Java's `UUID#fromString` method,
+     * only strings that don't have five parts and strings where any part exceed the maximum Long value are
+     * considered invalid.
+     *
+     * http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/default/src/share/classes/java/util/UUID.java
+     */
+    let isLegal = false;
+    if (raw.match(UuidPattern)) {
+        try {
+            const parts = raw.split('-').map(p => BigInt(`0x${p}`));
+            if (parts.every(p => p <= LongMax)) {
+                isLegal = true;
+                ans.bits[0] = BigInt.asIntN(64, (parts[0] << 32n) | (parts[1] << 16n) | parts[2]);
+                ans.bits[1] = BigInt.asIntN(64, (parts[3] << 48n) | parts[4]);
+            }
+        }
+        catch {
+            // Ignored.
+        }
+    }
+    ans.range.end = src.cursor;
+    if (!isLegal) {
+        ctx.err.report((0, locales_1.localize)('mcfunction.parser.uuid.invalid'), ans);
+    }
+    return ans;
+};
+function validateLength(parser, maxLength, localeKey) {
+    return (src, ctx) => {
+        if (!shouldValidateLength(ctx)) {
+            return parser(src, ctx);
+        }
+        return core.map(parser, (res, _src, ctx) => {
+            if (res.value.length > maxLength) {
+                ctx.err.report((0, locales_1.localize)(localeKey, maxLength), res);
+            }
+            return res;
+        })(src, ctx);
+    };
+}
+function validateUnquotable(parser) {
+    return core.map(parser, (res, _src, ctx) => {
+        if (!res.value.match(core.BrigadierUnquotablePattern)) {
+            ctx.err.report((0, locales_1.localize)('parser.string.illegal-brigadier', (0, locales_1.localeQuote)(res.value)), res);
+        }
+        return res;
+    });
+}
+function vector(options) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'mcfunction:vector',
+            range: core.Range.create(src),
+            children: [],
+            options,
+            system: 0 /* World */,
+        };
+        if (src.peek() === '^') {
+            ans.system = 1 /* Local */;
+        }
+        for (let i = 0; i < options.dimension; i++) {
+            if (i > 0) {
+                mcf.sep(src, ctx);
+            }
+            const coord = options.integersOnly ? coordinate(options.integersOnly)(src, ctx) : coordinate(options.integersOnly)(src, ctx);
+            ans.children.push(coord);
+            if ((ans.system === 1 /* Local */) !== (coord.notation === '^')) {
+                ctx.err.report((0, locales_1.localize)('mcfunction.parser.vector.mixed'), coord);
+            }
+        }
+        if (options.noLocal && ans.system === 1 /* Local */) {
+            ctx.err.report((0, locales_1.localize)('mcfunction.parser.vector.local-disallowed'), ans);
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+//# sourceMappingURL=argument.js.map