@spyglassmc/mcdoc 0.3.7 → 0.3.9

package/lib/parser/index.js

@@ -2,15 +2,13 @@ import * as core from '@spyglassmc/core';
 import { any, Arrayable, failOnEmpty, failOnError, Failure, map, optional, Range, repeat, ResourceLocation, select, sequence, setType, stopBefore, validate, } from '@spyglassmc/core';
 import { arrayToMessage, localeQuote, localize } from '@spyglassmc/locales';
 import { RangeExclusiveChar } from '../node/index.js';
-import { LiteralNumberCaseInsensitiveSuffixes, NumericTypeFloatKinds, NumericTypeIntKinds, PrimitiveArrayValueKinds, StaticIndexKeywords, } from '../type/index.js';
+import { NumericTypeFloatKinds, NumericTypeIntKinds, PrimitiveArrayValueKinds, StaticIndexKeywords, } from '../type/index.js';
 /**
  * @returns A comment parser that accepts normal comments (`//`) and reports an error if it's a doc comment (`///`).
  *
  * `Failure` when there isn't a comment.
  */
-export const comment = validate(core.comment({
-    singleLinePrefixes: new Set(['//']),
-}), (res, src) => !src.slice(res).startsWith('///'), localize('mcdoc.parser.syntax.doc-comment-unexpected'));
+export const comment = validate(core.comment({ singleLinePrefixes: new Set(['//']) }), (res, src) => !src.slice(res).startsWith('///'), localize('mcdoc.parser.syntax.doc-comment-unexpected'));
 /**
  * @returns A parser that parses the gap between **SYNTAX** rules, which may contains whitespace and regular comments.
  */
@@ -20,9 +18,7 @@ delegatesDocComments = false) {
     return (src, ctx) => {
         const ans = [];
         src.skipWhitespace();
-        while (src.canRead() &&
-            src.peek(2) === '//' &&
-            (!delegatesDocComments || src.peek(3) !== '///')) {
+        while (src.canRead() && src.peek(2) === '//' && (!delegatesDocComments || src.peek(3) !== '///')) {
             const result = comment(src, ctx);
             ans.push(result);
             src.skipWhitespace();
@@ -49,8 +45,7 @@ export function literal(literal, options) {
             value: '',
             colorTokenType: options?.colorTokenType,
         };
-        ans.value = src.readIf((c) => options?.allowedChars?.has(c) ??
-            (options?.specialChars?.has(c) || /[a-z]/i.test(c)));
+        ans.value = src.readIf((c) => options?.allowedChars?.has(c) ?? (options?.specialChars?.has(c) || /[a-z]/i.test(c)));
         ans.range.end = src.cursor;
         if (Arrayable.toArray(literal).every((l) => l !== ans.value)) {
             ctx.err.report(localize('expected-got', arrayToMessage(literal), localeQuote(ans.value)), ans);
@@ -108,10 +103,7 @@ const UnicodeControlCharacters = Object.freeze([
     '\x7F',
 ]);
 export const string = stopBefore(core.string({
-    escapable: {
-        characters: ['b', 'f', 'n', 'r', 't', '\\', '"'],
-        unicode: true,
-    },
+    escapable: { characters: ['b', 'f', 'n', 'r', 't', '\\', '"'], unicode: true },
     quotes: ['"'],
 }), ...UnicodeControlCharacters);
 export const identifier = (src, ctx) => {
@@ -159,17 +151,9 @@ export const identifier = (src, ctx) => {
 };
 function indexBody(options) {
     const accessorKey = select([
-        {
-            prefix: '%',
-            parser: literal(['%key', '%parent'], { specialChars: new Set(['%']) }),
-        },
-        {
-            prefix: '"',
-            parser: string,
-        },
-        {
-            parser: identifier,
-        },
+        { prefix: '%', parser: literal(['%key', '%parent'], { specialChars: new Set(['%']) }) },
+        { prefix: '"', parser: string },
+        { parser: identifier },
     ]);
     const dynamicIndex = setType('mcdoc:dynamic_index', syntax([
         punctuation('['),
@@ -182,10 +166,7 @@ function indexBody(options) {
             prefix: '%',
             parser: literal(StaticIndexKeywords.map((v) => `%${v}`), { specialChars: new Set(['%']) }),
         },
-        {
-            prefix: '"',
-            parser: string,
-        },
+        { prefix: '"', parser: string },
         {
             prefix: '[',
             parser: options?.noDynamic
@@ -194,10 +175,7 @@ function indexBody(options) {
         },
         {
             parser: any([
-                resLoc({
-                    category: 'mcdoc/dispatcher',
-                    accessType: options?.accessType,
-                }),
+                resLoc({ category: 'mcdoc/dispatcher', accessType: options?.accessType }),
                 identifier,
             ]),
         },
@@ -210,10 +188,10 @@ function indexBody(options) {
         punctuation(']'),
     ]));
 }
-const pathSegment = select([
-    { prefix: 'super', parser: literal('super') },
-    { parser: identifier },
-]);
+const pathSegment = select([{
+        prefix: 'super',
+        parser: literal('super'),
+    }, { parser: identifier }]);
 export const path = (src, ctx) => {
     let isAbsolute;
     if (src.trySkip('::')) {
@@ -235,13 +213,10 @@ const attributeTreePosValues = setType('mcdoc:attribute/tree/pos', syntax([
 ], true));
 const attributeNamedValue = syntax([
     select([{ prefix: '"', parser: string }, { parser: identifier }]),
-    select([
-        {
+    select([{
             prefix: '=',
             parser: syntax([punctuation('='), { get: () => attributeValue }], true),
-        },
-        { parser: { get: () => attributeTree } },
-    ]),
+        }, { parser: { get: () => attributeTree } }]),
 ], true);
 const attributeTreeNamedValues = setType('mcdoc:attribute/tree/named', syntax([
     attributeNamedValue,
@@ -257,11 +232,7 @@ const treeBody = any([
     ]),
     syntax([attributeTreePosValues, optional(marker(','))]),
 ]);
-const AttributeTreeClosure = Object.freeze({
-    '(': ')',
-    '[': ']',
-    '{': '}',
-});
+const AttributeTreeClosure = Object.freeze({ '(': ')', '[': ']', '{': '}' });
 const attributeTree = (src, ctx) => {
     const delim = src.trySkip('(')
         ? '('
@@ -283,30 +254,20 @@ const attributeTree = (src, ctx) => {
     src.trySkip(AttributeTreeClosure[delim]);
     return ans;
 };
-const attributeValue = select([
-    {
+const attributeValue = select([{
         predicate: (src) => ['(', '[', '{'].includes(src.peek()),
         parser: attributeTree,
-    },
-    { parser: { get: () => type } },
-]);
+    }, { parser: { get: () => type } }]);
 export const attribute = setType('mcdoc:attribute', syntax([
     marker('#['),
     identifier,
-    select([
-        {
+    select([{
             prefix: '=',
             parser: syntax([punctuation('='), attributeValue, punctuation(']')], true),
-        },
-        {
+        }, {
             predicate: (src) => ['(', '[', '{'].includes(src.peek()),
-            parser: syntax([
-                attributeTree,
-                punctuation(']'),
-            ], true),
-        },
-        { parser: punctuation(']') },
-    ]),
+            parser: syntax([attributeTree, punctuation(']')], true),
+        }, { parser: punctuation(']') }]),
 ], true));
 const attributes = repeat(attribute);
 const typeParam = setType('mcdoc:type_param', syntax([
@@ -315,17 +276,14 @@ const typeParam = setType('mcdoc:type_param', syntax([
 ]));
 const typeParamBlock = setType('mcdoc:type_param_block', syntax([
     punctuation('<'),
-    select([
-        { prefix: '>', parser: punctuation('>') },
-        {
+    select([{ prefix: '>', parser: punctuation('>') }, {
             parser: syntax([
                 typeParam,
                 syntaxRepeat(syntax([marker(','), failOnEmpty(typeParam)])),
                 optional(marker(',')),
                 punctuation('>'),
             ]),
-        },
-    ]),
+        }]),
 ]));
 const noop = () => undefined;
 export const docComment = core.comment({
@@ -336,48 +294,74 @@ export const docComments = setType('mcdoc:doc_comments', repeat(docComment, (src
     src.skipWhitespace();
     return [];
 }));
-const prelim = syntax([optional(failOnEmpty(docComments)), attributes]);
-const optionalTypeParamBlock = select([{ prefix: '<', parser: typeParamBlock }, { parser: noop }]);
+const prelim = syntax([
+    optional(failOnEmpty(docComments)),
+    attributes,
+]);
+const optionalTypeParamBlock = select([{
+        prefix: '<',
+        parser: typeParamBlock,
+    }, { parser: noop }]);
 export const dispatchStatement = setType('mcdoc:dispatch_statement', syntax([
     prelim,
     keyword('dispatch'),
-    resLoc({
-        category: 'mcdoc/dispatcher',
-        accessType: 1 /* SymbolAccessType.Write */,
-    }),
+    resLoc({ category: 'mcdoc/dispatcher', accessType: 1 /* SymbolAccessType.Write */ }),
     indexBody({ noDynamic: true }),
     optionalTypeParamBlock,
     literal('to'),
     { get: () => type },
 ], true));
-const enumType = literal(['byte', 'short', 'int', 'long', 'string', 'float', 'double'], { colorTokenType: 'type' });
+const enumType = literal([
+    'byte',
+    'short',
+    'int',
+    'long',
+    'string',
+    'float',
+    'double',
+], { colorTokenType: 'type' });
 export const float = core.float({
     pattern: /^[-+]?(?:[0-9]+(?:[eE][-+]?[0-9]+)?|[0-9]*\.[0-9]+(?:[eE][-+]?[0-9]+)?)$/,
 });
-export const typedNumber = setType('mcdoc:typed_number', sequence([
-    float,
-    optional(keyword(LiteralNumberCaseInsensitiveSuffixes, {
-        colorTokenType: 'keyword',
-    })),
-]));
-const enumValue = select([
-    { prefix: '"', parser: string },
-    { parser: typedNumber },
+export const integer = core.integer({
+    pattern: /^(?:0|[-+]?[1-9][0-9]*)$/,
+});
+export const LiteralIntSuffixes = Object.freeze(['b', 's', 'l']);
+export const LiteralIntCaseInsensitiveSuffixes = Object.freeze([...LiteralIntSuffixes, 'B', 'S', 'L']);
+export const LiteralFloatSuffixes = Object.freeze(['f', 'd']);
+export const LiteralFloatCaseInsensitiveSuffixes = Object.freeze([...LiteralFloatSuffixes, 'F', 'D']);
+export const LiteralNumberSuffixes = Object.freeze([...LiteralIntSuffixes, ...LiteralFloatSuffixes]);
+export const LiteralNumberCaseInsensitiveSuffixes = Object.freeze([
+    ...LiteralNumberSuffixes,
+    ...LiteralIntCaseInsensitiveSuffixes,
+    ...LiteralFloatCaseInsensitiveSuffixes,
 ]);
+export const typedNumber = setType('mcdoc:typed_number', select([{
+        regex: /^(?:\+|-)?\d+(?!\d|[.dfe])/i,
+        parser: sequence([
+            integer,
+            optional(keyword(LiteralIntCaseInsensitiveSuffixes, { colorTokenType: 'keyword' })),
+        ]),
+    }, {
+        parser: sequence([
+            float,
+            optional(keyword(LiteralFloatCaseInsensitiveSuffixes, { colorTokenType: 'keyword' })),
+        ]),
+    }]));
+const enumValue = select([{ prefix: '"', parser: string }, {
+        parser: typedNumber,
+    }]);
 const enumField = setType('mcdoc:enum/field', syntax([prelim, identifier, punctuation('='), enumValue], true));
 const enumBlock = setType('mcdoc:enum/block', syntax([
     punctuation('{'),
-    select([
-        { prefix: '}', parser: punctuation('}') },
-        {
+    select([{ prefix: '}', parser: punctuation('}') }, {
             parser: syntax([
                 enumField,
                 syntaxRepeat(syntax([marker(','), failOnEmpty(enumField)], true), true),
                 optional(marker(',')),
                 punctuation('}'),
             ], true),
-        },
-    ]),
+        }]),
 ], true));
 export const enum_ = setType('mcdoc:enum', syntax([
     prelim,
@@ -389,11 +373,10 @@ export const enum_ = setType('mcdoc:enum', syntax([
     enumBlock,
 ], true));
 const structMapKey = setType('mcdoc:struct/map_key', syntax([punctuation('['), { get: () => type }, punctuation(']')], true));
-const structKey = select([
-    { prefix: '"', parser: string },
-    { prefix: '[', parser: structMapKey },
-    { parser: identifier },
-]);
+const structKey = select([{ prefix: '"', parser: string }, {
+        prefix: '[',
+        parser: structMapKey,
+    }, { parser: identifier }]);
 const structPairField = (src, ctx) => {
     let isOptional;
     const result0 = syntax([prelim, structKey], true)(src, ctx);
@@ -410,58 +393,35 @@ const structPairField = (src, ctx) => {
     return ans;
 };
 const structSpreadField = setType('mcdoc:struct/field/spread', syntax([attributes, marker('...'), { get: () => type }], true));
-const structField = any([structSpreadField, structPairField]);
+const structField = any([
+    structSpreadField,
+    structPairField,
+]);
 const structBlock = setType('mcdoc:struct/block', syntax([
     punctuation('{'),
-    select([
-        { prefix: '}', parser: punctuation('}') },
-        {
+    select([{ prefix: '}', parser: punctuation('}') }, {
             parser: syntax([
                 structField,
                 syntaxRepeat(syntax([marker(','), failOnEmpty(structField)], true), true),
                 optional(marker(',')),
                 punctuation('}'),
             ], true),
-        },
-    ]),
-], true));
-export const struct = setType('mcdoc:struct', syntax([
-    prelim,
-    keyword('struct'),
-    optional(failOnEmpty(identifier)),
-    structBlock,
+        }]),
 ], true));
-const enumInjection = setType('mcdoc:injection/enum', syntax([
-    literal('enum'),
-    punctuation('('),
-    enumType,
-    punctuation(')'),
-    path,
-    enumBlock,
-]));
+export const struct = setType('mcdoc:struct', syntax([prelim, keyword('struct'), optional(failOnEmpty(identifier)), structBlock], true));
+const enumInjection = setType('mcdoc:injection/enum', syntax([literal('enum'), punctuation('('), enumType, punctuation(')'), path, enumBlock]));
 const structInjection = setType('mcdoc:injection/struct', syntax([literal('struct'), path, structBlock]));
 export const injection = setType('mcdoc:injection', syntax([
     keyword('inject'),
-    select([
-        { prefix: 'enum', parser: enumInjection },
-        { parser: structInjection },
-    ]),
+    select([{ prefix: 'enum', parser: enumInjection }, { parser: structInjection }]),
 ]));
-export const typeAliasStatement = setType('mcdoc:type_alias', syntax([
-    prelim,
-    keyword('type'),
-    identifier,
-    optionalTypeParamBlock,
-    punctuation('='),
-    { get: () => type },
-], true));
+export const typeAliasStatement = setType('mcdoc:type_alias', syntax([prelim, keyword('type'), identifier, optionalTypeParamBlock, punctuation('='), {
+        get: () => type,
+    }], true));
 export const useStatement = setType('mcdoc:use_statement', syntax([
     keyword('use'),
     path,
-    select([
-        { prefix: 'as', parser: syntax([literal('as'), identifier]) },
-        { parser: noop },
-    ]),
+    select([{ prefix: 'as', parser: syntax([literal('as'), identifier]) }, { parser: noop }]),
 ], true));
 const topLevel = any([
     comment,
@@ -475,34 +435,25 @@ const topLevel = any([
 export const module_ = setType('mcdoc:module', syntaxRepeat(topLevel, true));
 const typeArgBlock = setType('mcdoc:type_arg_block', syntax([
     marker('<'),
-    select([
-        { prefix: '>', parser: punctuation('>') },
-        {
+    select([{ prefix: '>', parser: punctuation('>') }, {
             parser: syntax([
                 { get: () => type },
                 syntaxRepeat(syntax([marker(','), { get: () => failOnEmpty(type) }], true), true),
                 optional(marker(',')),
                 punctuation('>'),
             ], true),
-        },
-    ]),
+        }]),
 ]));
 /* eslint-enable @typescript-eslint/indent */
 function typeBase(type, parser) {
     return setType(type, syntax([
         attributes,
         parser,
-        syntaxRepeat(select([
-            { prefix: '<', parser: typeArgBlock },
-            { parser: failOnError(indexBody()) },
-        ]), true),
+        syntaxRepeat(select([{ prefix: '<', parser: typeArgBlock }, { parser: failOnError(indexBody()) }]), true),
     ], true));
 }
 export const anyType = typeBase('mcdoc:type/any', keyword('any', { colorTokenType: 'type' }));
 export const booleanType = typeBase('mcdoc:type/boolean', keyword('boolean', { colorTokenType: 'type' }));
-export const integer = core.integer({
-    pattern: /^(?:0|[-+]?[1-9][0-9]*)$/,
-});
 function range(type, number) {
     const delimiterPredicate = (src) => src.tryPeek('..') || src.tryPeek(`${RangeExclusiveChar}..`);
     const delimiterParser = literal([
@@ -510,30 +461,16 @@ function range(type, number) {
         `..${RangeExclusiveChar}`,
         `${RangeExclusiveChar}..`,
         `${RangeExclusiveChar}..${RangeExclusiveChar}`,
-    ], {
-        allowedChars: new Set(['.', RangeExclusiveChar]),
-    });
-    return setType(type, select([
-        {
-            predicate: delimiterPredicate,
-            parser: sequence([delimiterParser, number]),
-        },
-        {
+    ], { allowedChars: new Set(['.', RangeExclusiveChar]) });
+    return setType(type, select([{ predicate: delimiterPredicate, parser: sequence([delimiterParser, number]) }, {
             parser: sequence([
                 stopBefore(number, '..'),
-                select([
-                    {
+                select([{
                         predicate: delimiterPredicate,
-                        parser: sequence([
-                            delimiterParser,
-                            optional(failOnEmpty(number)),
-                        ]),
-                    },
-                    { parser: noop },
-                ]),
+                        parser: sequence([delimiterParser, optional(failOnEmpty(number))]),
+                    }, { parser: noop }]),
             ]),
-        },
-    ]));
+        }]));
 }
 export const intRange = range('mcdoc:int_range', integer);
 const atIntRange = optional((src, ctx) => {
@@ -543,7 +480,10 @@ const atIntRange = optional((src, ctx) => {
     src.skipWhitespace();
     return intRange(src, ctx);
 });
-export const stringType = typeBase('mcdoc:type/string', syntax([keyword('string', { colorTokenType: 'type' }), atIntRange]));
+export const stringType = typeBase('mcdoc:type/string', syntax([
+    keyword('string', { colorTokenType: 'type' }),
+    atIntRange,
+], true));
 export const literalType = typeBase('mcdoc:type/literal', select([
     {
         predicate: (src) => src.tryPeek('false') || src.tryPeek('true'),
@@ -560,28 +500,16 @@ const atFloatRange = optional((src, ctx) => {
     src.skipWhitespace();
     return floatRange(src, ctx);
 });
-export const numericType = typeBase('mcdoc:type/numeric_type', select([
-    {
+export const numericType = typeBase('mcdoc:type/numeric_type', select([{
         predicate: (src) => NumericTypeFloatKinds.some((k) => src.tryPeek(k)),
-        parser: syntax([
-            keyword(NumericTypeFloatKinds, { colorTokenType: 'type' }),
-            atFloatRange,
-        ], true),
-    },
-    {
-        parser: syntax([
-            keyword(NumericTypeIntKinds, { colorTokenType: 'type' }),
-            atIntRange,
-        ], true),
-    },
-]));
+        parser: syntax([keyword(NumericTypeFloatKinds, { colorTokenType: 'type' }), atFloatRange], true),
+    }, {
+        parser: syntax([keyword(NumericTypeIntKinds, { colorTokenType: 'type' }), atIntRange], true),
+    }]));
 export const primitiveArrayType = typeBase('mcdoc:type/primitive_array', syntax([
     literal(PrimitiveArrayValueKinds),
     atIntRange,
-    keyword('[]', {
-        allowedChars: new Set(['[', ']']),
-        colorTokenType: 'type',
-    }),
+    keyword('[]', { allowedChars: new Set(['[', ']']), colorTokenType: 'type' }),
     atIntRange,
 ]));
 export const listType = typeBase('mcdoc:type/list', syntax([marker('['), { get: () => type }, punctuation(']'), atIntRange], true));
@@ -589,32 +517,26 @@ export const tupleType = typeBase('mcdoc:type/tuple', syntax([
     marker('['),
     { get: () => type },
     marker(','),
-    select([
-        { prefix: ']', parser: punctuation(']') },
-        {
+    select([{ prefix: ']', parser: punctuation(']') }, {
             parser: syntax([
                 { get: () => type },
                 syntaxRepeat(syntax([marker(','), { get: () => failOnEmpty(type) }], true), true),
                 optional(marker(',')),
                 punctuation(']'),
             ], true),
-        },
-    ]),
+        }]),
 ], true));
 export const dispatcherType = typeBase('mcdoc:type/dispatcher', syntax([failOnError(resLoc({ category: 'mcdoc/dispatcher' })), indexBody()]));
 export const unionType = typeBase('mcdoc:type/union', syntax([
     marker('('),
-    select([
-        { prefix: ')', parser: punctuation(')') },
-        {
+    select([{ prefix: ')', parser: punctuation(')') }, {
             parser: syntax([
                 { get: () => type },
                 syntaxRepeat(syntax([marker('|'), { get: () => failOnEmpty(type) }], true), true),
                 optional(marker('|')),
                 punctuation(')'),
             ], true),
-        },
-    ]),
+        }]),
 ]));
 export const referenceType = typeBase('mcdoc:type/reference', syntax([path]));
 export const type = any([

package/lib/runtime/attribute/builtin.d.ts

@@ -0,0 +1,3 @@
+import * as core from '@spyglassmc/core';
+export declare function registerBuiltinAttributes(meta: core.MetaRegistry): void;
+//# sourceMappingURL=builtin.d.ts.map

package/lib/runtime/attribute/builtin.js

@@ -0,0 +1,130 @@
+import * as core from '@spyglassmc/core';
+import { registerAttribute, validator } from './index.js';
+const idValidator = validator.alternatives(validator.map(validator.string, v => ({ registry: v })), validator.tree({
+    registry: validator.string,
+    tags: validator.optional(validator.options('allowed', 'implicit', 'required')),
+    definition: validator.optional(validator.boolean),
+    prefix: validator.optional(validator.options('!')),
+}), () => ({}));
+function getResourceLocationOptions({ registry, tags, definition }, requireCanonical, ctx, typeDef) {
+    if (!registry) {
+        if (typeDef?.kind === 'enum' && typeDef.enumKind === 'string') {
+            return {
+                pool: typeDef.values.map(v => core.ResourceLocation.lengthen(`${v.value}`)),
+                allowUnknown: true, // the mcdoc checker will already report errors for this
+            };
+        }
+        if (typeDef?.kind === 'literal' && typeDef.value.kind === 'string') {
+            return {
+                pool: [core.ResourceLocation.lengthen(typeDef.value.value)],
+                allowUnknown: true,
+            };
+        }
+        return { pool: [], allowUnknown: true };
+    }
+    if (tags === 'implicit') {
+        registry = `tag/${registry}`;
+    }
+    // TODO: disallow non-tags when tags=required
+    if (tags === 'allowed' || tags === 'required') {
+        if (core.TaggableResourceLocationCategory.is(registry)) {
+            return {
+                category: registry,
+                requireCanonical,
+                allowTag: true,
+            };
+        }
+    }
+    else if (core.ResourceLocationCategory.is(registry)) {
+        return {
+            category: registry,
+            requireCanonical,
+            usageType: definition ? 'definition' : 'reference',
+        };
+    }
+    ctx.logger.warn(`[mcdoc id] Unhandled registry ${registry}`);
+    return undefined;
+}
+export function registerBuiltinAttributes(meta) {
+    registerAttribute(meta, 'canonical', () => undefined, {
+    // Has hardcoded behavior in the runtime checker
+    });
+    registerAttribute(meta, 'dispatcher_key', validator.string, {
+        stringMocker: (config, _, ctx) => {
+            const symbol = ctx.symbols.query(ctx.doc, 'mcdoc/dispatcher', config).symbol;
+            const keys = Object.keys(symbol?.members ?? {}).filter(m => !m.startsWith('%'));
+            return core.LiteralNode.mock(ctx.offset, { pool: keys });
+        },
+    });
+    registerAttribute(meta, 'id', idValidator, {
+        checkInferred: (config, inferred, ctx) => {
+            if (inferred.kind === 'string') {
+                // Internal mcdoc isAssignable check
+                const idAttr = inferred.attributes?.find(a => a.name === 'id');
+                if (idAttr) {
+                    const inferredConfig = idValidator(idAttr.value, ctx);
+                    return inferredConfig === core.Failure || inferredConfig.prefix === config.prefix;
+                    // Prefix doesn't match
+                }
+            }
+            if (inferred.kind !== 'literal' || inferred.value.kind !== 'string') {
+                return true; // Ignore attribute when not a string
+            }
+            if (config.prefix && !inferred.value.value.startsWith(config.prefix)) {
+                return false; // Missing prefix
+            }
+            if (!config.prefix && inferred.value.value.startsWith('!')) {
+                return false; // Unexpected prefix
+            }
+            if (!inferred.value.value.includes(':')) {
+                if (config.prefix) {
+                    inferred.value.value = config.prefix + 'minecraft:'
+                        + inferred.value.value.slice(config.prefix.length);
+                }
+                else {
+                    inferred.value.value = 'minecraft:' + inferred.value.value;
+                }
+            }
+            return true;
+        },
+        mapType: (config, typeDef, ctx) => {
+            if (typeDef.kind === 'literal' && typeDef.value.kind === 'string') {
+                const value = core.ResourceLocation.lengthen(typeDef.value.value);
+                return { ...typeDef, value: { kind: 'string', value } };
+            }
+            if (typeDef.kind === 'enum' && typeDef.enumKind === 'string') {
+                const values = typeDef.values.map(v => ({
+                    ...v,
+                    value: core.ResourceLocation.lengthen(`${v.value}`),
+                }));
+                return { ...typeDef, values };
+            }
+            return typeDef;
+        },
+        stringParser: (config, typeDef, ctx) => {
+            const options = getResourceLocationOptions(config, ctx.requireCanonical, ctx, typeDef);
+            if (!options) {
+                return;
+            }
+            const resourceLocation = core.resourceLocation(options);
+            return (src, ctx) => {
+                if (config.prefix) {
+                    return core.prefixed({ prefix: config.prefix, child: resourceLocation })(src, ctx);
+                }
+                return resourceLocation(src, ctx);
+            };
+        },
+        stringMocker: (config, typeDef, ctx) => {
+            const options = getResourceLocationOptions(config, ctx.requireCanonical ?? false, ctx, typeDef);
+            if (!options) {
+                return undefined;
+            }
+            const resourceLocation = core.ResourceLocationNode.mock(ctx.offset, options);
+            if (config.prefix) {
+                return core.PrefixedNode.mock(ctx.offset, config.prefix, resourceLocation);
+            }
+            return resourceLocation;
+        },
+    });
+}
+//# sourceMappingURL=builtin.js.map