@spyglassmc/json 0.3.7 → 0.3.9

package/lib/checker/index.d.ts

@@ -0,0 +1,10 @@
+import * as core from '@spyglassmc/core';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { JsonNode, TypedJsonNode } from '../node/index.js';
+export declare const typed: core.SyncChecker<TypedJsonNode>;
+export declare function register(meta: core.MetaRegistry): void;
+export interface JsonCheckerOptions {
+    discardDuplicateKeyErrors?: true;
+}
+export declare function index(type: mcdoc.McdocType, options?: JsonCheckerOptions): core.SyncChecker<JsonNode>;
+//# sourceMappingURL=index.d.ts.map

package/lib/checker/index.js

@@ -0,0 +1,109 @@
+import * as core from '@spyglassmc/core';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { JsonPairNode, JsonStringNode } from '../node/index.js';
+export const typed = (node, ctx) => {
+    index(node.targetType)(node.children[0], ctx);
+};
+export function register(meta) {
+    meta.registerChecker('json:typed', typed);
+}
+export function index(type, options) {
+    return (node, ctx) => {
+        mcdoc.runtime.checker.typeDefinition([{ originalNode: node, inferredType: inferType(node) }], type, mcdoc.runtime.checker.McdocCheckerContext.create(ctx, {
+            isEquivalent: (inferred, def) => {
+                switch (inferred.kind) {
+                    case 'list':
+                        return ['list', 'byte_array', 'int_array', 'long_array', 'tuple'].includes(def.kind);
+                    case 'struct':
+                        return def.kind === 'struct';
+                    case 'byte':
+                    case 'short':
+                    case 'int':
+                    case 'long':
+                        return ['byte', 'short', 'int', 'long', 'float', 'double'].includes(def.kind);
+                    case 'float':
+                    case 'double':
+                        return ['float', 'double'].includes(def.kind);
+                    default:
+                        return false;
+                }
+            },
+            getChildren: node => {
+                if (node.type === 'json:array') {
+                    return node.children.filter(n => n.value).map(n => [{ originalNode: n.value, inferredType: inferType(n.value) }]);
+                }
+                if (node.type === 'json:object') {
+                    return node.children.filter(kvp => kvp.key).map(kvp => ({
+                        key: { originalNode: kvp.key, inferredType: inferType(kvp.key) },
+                        possibleValues: kvp.value
+                            ? [{ originalNode: kvp.value, inferredType: inferType(kvp.value) }]
+                            : [],
+                    }));
+                }
+                return [];
+            },
+            reportError: err => {
+                if (err.kind === 'duplicate_key' && options?.discardDuplicateKeyErrors) {
+                    return;
+                }
+                mcdoc.runtime.checker.getDefaultErrorReporter(ctx, (mcdoc.runtime.checker.getDefaultErrorRange))(err);
+            },
+            attachTypeInfo: (node, definition, desc = '') => {
+                node.typeDef = definition;
+                // TODO: improve hover info
+                // TODO some sort of shared default implementaion between JSON and SNBT (DRY)
+                if (node.parent && JsonPairNode?.is(node.parent)) {
+                    if (node.parent.key?.typeDef && node.parent.value?.typeDef) {
+                        const valueString = mcdoc.McdocType.toString(node.parent.value.typeDef);
+                        let keyString = mcdoc.McdocType.toString(node.parent.key.typeDef);
+                        if (node.parent.key.typeDef.kind !== 'literal') {
+                            keyString = `[${keyString}]`;
+                        }
+                        const hover = `\`\`\`typescript\n${keyString}: ${valueString}\n\`\`\`\n${desc}`;
+                        node.parent.key.hover = hover;
+                        if (node.parent.value.type !== 'json:array'
+                            && node.parent.value.type !== 'json:object') {
+                            node.parent.value.hover =
+                                `\`\`\`typescript\n${valueString}\n\`\`\`\n${desc}`;
+                        }
+                    }
+                }
+                else if (node.type !== 'json:array' && node.type !== 'json:object') {
+                    node.hover = `\`\`\`typescript\n${mcdoc.McdocType.toString(definition)}\n\`\`\`\n${desc}`;
+                }
+            },
+            stringAttacher: (node, attacher) => {
+                if (!JsonStringNode.is(node)) {
+                    return;
+                }
+                attacher(node);
+                if (node.children) {
+                    core.AstNode.setParents(node);
+                    // Because the runtime checker happens after binding, we need to manually call this
+                    core.binder.fallbackSync(node, ctx);
+                    core.checker.fallbackSync(node, ctx);
+                }
+            },
+        }));
+    };
+}
+function inferType(node) {
+    switch (node.type) {
+        case 'json:boolean':
+            return { kind: 'literal', value: { kind: 'boolean', value: node.value } };
+        case 'json:number':
+            return {
+                kind: 'literal',
+                value: { kind: node.value.type, value: Number(node.value.value) },
+            };
+        case 'json:null':
+            return { kind: 'any' }; // null is always invalid?
+        case 'json:string':
+            return { kind: 'literal', value: { kind: 'string', value: node.value } };
+        case 'json:array':
+            return { kind: 'list', item: { kind: 'any' } };
+        case 'json:object':
+            return { kind: 'struct', fields: [] };
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/colorizer/index.d.ts

@@ -1,7 +1,8 @@
 import type { Colorizer, MetaRegistry } from '@spyglassmc/core';
-import type { JsonBooleanNode, JsonNullNode, JsonObjectNode } from '../node/index.js';
+import type { JsonBooleanNode, JsonNullNode, JsonObjectNode, JsonStringNode } from '../node/index.js';
 export declare const boolean: Colorizer<JsonBooleanNode>;
 export declare const null_: Colorizer<JsonNullNode>;
 export declare const object: Colorizer<JsonObjectNode>;
+export declare const string: Colorizer<JsonStringNode>;
 export declare function register(meta: MetaRegistry): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/colorizer/index.js

@@ -19,11 +19,19 @@ export const object = (node, ctx) => {
     }
     return ans;
 };
+export const string = (node, ctx) => {
+    if (node.children && node.children?.length > 0) {
+        const child = node.children[0];
+        const colorizer = ctx.meta.getColorizer(child.type);
+        return colorizer(child, ctx);
+    }
+    return core.colorizer.string(node, ctx);
+};
 export function register(meta) {
     meta.registerColorizer('json:boolean', boolean);
     meta.registerColorizer('json:null', null_);
     meta.registerColorizer('json:number', core.colorizer.number);
     meta.registerColorizer('json:object', object);
-    meta.registerColorizer('json:string', core.colorizer.string);
+    meta.registerColorizer('json:string', string);
 }
 //# sourceMappingURL=index.js.map

package/lib/completer/index.d.ts

@@ -1,9 +1,3 @@
-import type { Completer, MetaRegistry } from '@spyglassmc/core';
-import type { JsonArrayNode, JsonBooleanNode, JsonNode, JsonObjectNode } from '../node/index.js';
-export declare const JsonTriggerCharacters: string[];
-export declare const entry: Completer<JsonNode>;
-export declare const object: Completer<JsonObjectNode>;
-export declare const array: Completer<JsonArrayNode>;
-export declare const boolean: Completer<JsonBooleanNode>;
-export declare function register(meta: MetaRegistry): void;
+import * as core from '@spyglassmc/core';
+export declare function register(meta: core.MetaRegistry): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/completer/index.js

@@ -1,146 +1,84 @@
 import * as core from '@spyglassmc/core';
-import { CompletionItem, Range } from '@spyglassmc/core';
-import { JsonExpectation } from '../node/index.js';
-export const JsonTriggerCharacters = ['\n', ':', '"'];
-const SIMPLE_SNIPPETS = {
-    'json:object': '{$1}',
-    'json:array': '[$1]',
-    'json:string': '"$1"',
-    'json:boolean': '${1|false,true|}',
-    'json:number': '${1:0}',
-};
-export const entry = (node, ctx) => {
-    return core.completer.dispatch(node, ctx);
+import * as mcdoc from '@spyglassmc/mcdoc';
+const array = (node, ctx) => {
+    const index = core.binarySearch(node.children, ctx.offset, (n, o) => {
+        return core.Range.compareOffset(n.range, o, true);
+    });
+    const item = index >= 0 ? node.children[index] : undefined;
+    if (item?.value) {
+        return ctx.meta.getCompleter(item.value.type)(item.value, ctx);
+    }
+    if (node.typeDef?.kind === 'list') {
+        const completions = getValues(node.typeDef.item, ctx.offset, ctx);
+        if (ctx.offset < node.children[node.children.length - 1]?.range.start ?? 0) {
+            return completions.map(c => ({ ...c, insertText: c.insertText + ',' }));
+        }
+        return completions;
+    }
+    return [];
 };
-export const object = core.completer.record({
-    key: (record, pair, ctx, range, insertValue, insertComma) => {
-        if (record.expectation) {
-            return unique(record.expectation
-                .filter(JsonExpectation.isObject)
-                .flatMap((e) => objectCompletion(range, record, e, ctx, insertValue, insertComma, pair?.key?.value)));
+const object = core.completer.record({
+    key: (record, pair, ctx, range, iv, ipe, exitingKeys) => {
+        if (!record.typeDef) {
+            return [];
         }
-        return [];
+        const keySet = new Set(exitingKeys.map(n => n.value));
+        return mcdoc.runtime.completer
+            .getFields(record.typeDef, ctx)
+            .filter(({ key }) => !keySet.has(key))
+            .map(({ key, field }) => core.CompletionItem.create(key, pair?.key ?? range, {
+            kind: 5 /* core.CompletionKind.Field */,
+            detail: mcdoc.McdocType.toString(field.type),
+            deprecated: field.deprecated,
+            sortText: field.optional ? '$b' : '$a', // sort above hardcoded $schema
+            filterText: `"${key}"`,
+            insertText: `"${key}"${iv ? ': ' : ''}${ipe ? '$1,' : ''}`,
+        }));
     },
-    value: (record, pair, ctx) => {
-        if (pair.value && !Range.isEmpty(pair.value)) {
-            return core.completer.dispatch(pair.value, ctx);
+    value: (record, pair, ctx, range) => {
+        if (pair.value) {
+            return ctx.meta.getCompleter(pair.value.type)(pair.value, ctx);
         }
-        if (record.expectation) {
-            return unique(record.expectation
-                .filter(JsonExpectation.isObject)
-                .filter((e) => e.fields)
-                .map((e) => e.fields.find((f) => f.key === pair.key?.value))
-                .flatMap((f) => valueCompletion(ctx.offset, f.value, ctx)));
+        if (pair.key && record.typeDef) {
+            const pairKey = pair.key.value;
+            const field = mcdoc.runtime.completer.getFields(record.typeDef, ctx)
+                .find(({ key }) => key === pairKey)
+                ?.field.type;
+            if (field) {
+                return getValues(field, range, ctx);
+            }
         }
         return [];
     },
 });
-export const array = (node, ctx) => {
-    const index = core.binarySearch(node.children, ctx.offset, (n, o) => n.sep
-        ? Range.compareOffset(Range.translate(n, 0, -1), o, true)
-        : Range.compareOffset(n.range, o, true));
-    const item = index >= 0 ? node.children[index] : undefined;
-    if (item?.value) {
-        return core.completer.dispatch(item.value, ctx);
-    }
-    if (node.expectation &&
-        Range.contains(Range.translate(node, 1, -1), ctx.offset, true)) {
-        return unique(node.expectation
-            .filter(JsonExpectation.isArray)
-            .filter((e) => e.items)
-            .flatMap((e) => valueCompletion(ctx.offset, e.items, ctx)));
-    }
-    return [];
-};
-export const boolean = (node) => {
-    return ['false', 'true'].map((v) => simpleCompletion(node, v));
-};
-const string = (node, ctx) => {
-    if (node.children?.length) {
-        return core.completer.string(node, ctx);
+const primitive = (node, ctx) => {
+    const insideRange = core.Range.contains(node, ctx.offset, true);
+    if (node.type === 'json:string' && node.children?.length && insideRange) {
+        const childItems = core.completer.string(node, ctx);
+        if (childItems.length > 0) {
+            return childItems;
+        }
     }
-    if (node.expectation) {
-        return unique(node.expectation
-            .filter(JsonExpectation.isString)
-            .flatMap((e) => stringCompletion(node, e, ctx)));
+    if (!node.typeDef) {
+        return [];
     }
-    return [];
+    return getValues(node.typeDef, insideRange ? node : ctx.offset, ctx);
 };
-function objectCompletion(range, node, expectation, ctx, insertValue, insertComma, selectedKey) {
-    if (expectation.fields) {
-        return expectation
-            .fields.filter((f) => f.key === selectedKey ||
-            !node.children.find((p) => f.key === p.key?.value))
-            .map((f) => fieldCompletion(range, f, insertValue, insertComma));
-    }
-    else if (expectation.keys) {
-        return expectation.keys.flatMap((e) => stringCompletion(range, e, ctx).map((c) => ({
-            ...c,
-            ...(insertValue
-                ? { insertText: `${c.insertText}: ${insertComma ? ',' : ''}` }
-                : {}),
-        })));
-    }
-    return [];
-}
-function fieldCompletion(range, field, insertValue, insertComma) {
-    const value = field.value?.[0] ? SIMPLE_SNIPPETS[field.value[0].type] : '';
-    return CompletionItem.create(field.key, range, {
-        kind: 10 /* CompletionKind.Property */,
-        detail: field.value?.map((e) => e.typedoc).join(' | '),
-        sortText: `${field.deprecated ? 2 : field.opt ? 1 : 0}${field.key}`,
-        deprecated: field.deprecated,
-        filterText: `"${field.key}"`,
-        insertText: `"${field.key}"${insertValue ? `: ${value}` : ''}${insertComma ? ',' : ''}`,
-    });
-}
-function valueCompletion(range, expectation, ctx) {
-    return unique(expectation.flatMap((e) => {
-        switch (e.type) {
-            case 'json:object':
-            case 'json:array':
-                return [simpleCompletion(range, SIMPLE_SNIPPETS[e.type])];
-            case 'json:string':
-                return stringCompletion(ctx.offset, e, ctx);
-            case 'json:boolean':
-                return ['false', 'true'].map((v) => simpleCompletion(range, v));
-            case 'json:number':
-                return [simpleCompletion(range, '0')];
-        }
+function getValues(typeDef, range, ctx) {
+    return mcdoc.runtime.completer.getValues(typeDef, ctx)
+        .map(({ value, detail, kind, completionKind, insertText }) => core.CompletionItem.create(value, range, {
+        kind: completionKind ?? 12 /* core.CompletionKind.Value */,
+        detail,
+        filterText: kind === 'string' ? `"${value}"` : value,
+        insertText: kind === 'string' ? `"${insertText ?? value}"` : insertText ?? value,
     }));
 }
-function stringCompletion(range, expectation, ctx) {
-    if (Array.isArray(expectation.pool)) {
-        return expectation.pool.map((v) => CompletionItem.create(v, range, {
-            kind: 12 /* CompletionKind.Value */,
-            filterText: `"${v}"`,
-            insertText: `"${v}"`,
-        }));
-    }
-    return [simpleCompletion(range, SIMPLE_SNIPPETS[expectation.type])];
-}
-function simpleCompletion(range, value) {
-    return CompletionItem.create(value.replace('$1', ''), range, {
-        kind: 12 /* CompletionKind.Value */,
-        insertText: value,
-    });
-}
-function unique(completions) {
-    const ans = [];
-    const labels = new Set();
-    completions.forEach((c) => {
-        if (!labels.has(c.label)) {
-            labels.add(c.label);
-            ans.push(c);
-        }
-    });
-    return ans;
-}
 export function register(meta) {
-    meta.registerCompleter('json:entry', entry);
     meta.registerCompleter('json:array', array);
-    meta.registerCompleter('json:boolean', boolean);
+    meta.registerCompleter('json:boolean', primitive);
+    meta.registerCompleter('json:number', primitive);
+    meta.registerCompleter('json:null', primitive);
     meta.registerCompleter('json:object', object);
-    meta.registerCompleter('json:string', string);
+    meta.registerCompleter('json:string', primitive);
 }
 //# sourceMappingURL=index.js.map

package/lib/formatter/index.js

@@ -1,22 +1,24 @@
 import * as core from '@spyglassmc/core';
 import { indentFormatter } from '@spyglassmc/core';
 const array = (node, ctx) => {
-    if (node.children.length === 0)
+    if (node.children.length === 0) {
         return '[]';
+    }
     const values = node.children.map((child) => {
-        const value = child.value &&
-            ctx.meta.getFormatter(child.value.type)(child.value, indentFormatter(ctx));
+        const value = child.value
+            && ctx.meta.getFormatter(child.value.type)(child.value, indentFormatter(ctx));
         return `${ctx.indent(1)}${value ?? ''}`;
     });
     return `[\n${values.join(',\n')}\n${ctx.indent()}]`;
 };
 const object = (node, ctx) => {
-    if (node.children.length === 0)
+    if (node.children.length === 0) {
         return '{}';
+    }
     const fields = node.children.map((child) => {
         const key = child.key && core.formatter.string(child.key, ctx);
-        const value = child.value &&
-            ctx.meta.getFormatter(child.value.type)(child.value, indentFormatter(ctx));
+        const value = child.value
+            && ctx.meta.getFormatter(child.value.type)(child.value, indentFormatter(ctx));
         return `${ctx.indent(1)}${key ?? ''}: ${value ?? ''}`;
     });
     return `{\n${fields.join(',\n')}\n${ctx.indent()}}`;

package/lib/index.d.ts

@@ -1,4 +1,5 @@
-import * as core from '@spyglassmc/core';
+import type * as core from '@spyglassmc/core';
+export * as checker from './checker/index.js';
 export * as colorizer from './colorizer/index.js';
 export * as completer from './completer/index.js';
 export * as formatter from './formatter/index.js';

package/lib/index.js

@@ -1,9 +1,10 @@
 /* istanbul ignore file */
-import * as core from '@spyglassmc/core';
+import * as checker from './checker/index.js';
 import * as colorizer from './colorizer/index.js';
 import * as completer from './completer/index.js';
 import * as formatter from './formatter/index.js';
 import * as parser from './parser/index.js';
+export * as checker from './checker/index.js';
 export * as colorizer from './colorizer/index.js';
 export * as completer from './completer/index.js';
 export * as formatter from './formatter/index.js';
@@ -11,11 +12,17 @@ export * from './node/index.js';
 export * as parser from './parser/index.js';
 export const initialize = ({ meta }) => {
     meta.registerLanguage('json', {
-        extensions: ['.json', '.mcmeta'],
-        triggerCharacters: completer.JsonTriggerCharacters,
-        parser: core.dumpErrors(parser.entry),
+        extensions: ['.json'],
+        triggerCharacters: ['\n', ':', '"'],
+        parser: parser.file,
+    });
+    meta.registerLanguage('mcmeta', {
+        extensions: ['.mcmeta'],
+        triggerCharacters: ['\n', ':', '"'],
+        parser: parser.file,
     });
     meta.registerParser('json:entry', parser.entry);
+    checker.register(meta);
     colorizer.register(meta);
     completer.register(meta);
     formatter.register(meta);

package/lib/node/index.d.ts

@@ -1,2 +1,72 @@
-export * from './JsonAstNode.js';
+import * as core from '@spyglassmc/core';
+import type * as mcdoc from '@spyglassmc/mcdoc';
+export interface JsonFileNode extends core.AstNode {
+    readonly type: 'json:file';
+    readonly children: [JsonNode];
+}
+export declare namespace JsonFileNode {
+    function is(obj: object | undefined): obj is JsonFileNode;
+}
+interface JsonBaseNode {
+    typeDef?: mcdoc.runtime.checker.SimplifiedMcdocType;
+}
+export type JsonNode = JsonObjectNode | JsonArrayNode | JsonPrimitiveNode;
+export declare namespace JsonNode {
+    function is(node: core.AstNode): node is JsonNode;
+}
+export interface JsonObjectNode extends core.RecordBaseNode<JsonStringNode, JsonNode>, JsonBaseNode {
+    readonly type: 'json:object';
+}
+export declare namespace JsonObjectNode {
+    function is(obj: object | undefined): obj is JsonObjectNode;
+    function mock(range: core.RangeLike): JsonObjectNode;
+}
+export type JsonPairNode = core.PairNode<JsonStringNode, JsonNode>;
+export declare namespace JsonPairNode {
+    function is(obj: object): obj is JsonPairNode;
+}
+export interface JsonArrayNode extends core.ListNode<JsonNode>, JsonBaseNode {
+    readonly type: 'json:array';
+}
+export declare namespace JsonArrayNode {
+    function is(obj: object | undefined): obj is JsonArrayNode;
+    function mock(range: core.RangeLike): JsonArrayNode;
+}
+export type JsonPrimitiveNode = JsonStringNode | JsonNumberNode | JsonBooleanNode | JsonNullNode;
+export interface JsonStringNode extends core.StringBaseNode, JsonBaseNode {
+    readonly type: 'json:string';
+}
+export declare namespace JsonStringNode {
+    function is(obj: object | undefined): obj is JsonStringNode;
+    function mock(range: core.RangeLike): JsonStringNode;
+}
+export interface JsonNumberNode extends core.AstNode, JsonBaseNode {
+    readonly type: 'json:number';
+    readonly children: [core.LongNode | core.FloatNode];
+    readonly value: core.LongNode | core.FloatNode;
+}
+export declare namespace JsonNumberNode {
+    function is(obj: object): obj is JsonNumberNode;
+}
+export interface JsonBooleanNode extends core.BooleanBaseNode, JsonBaseNode {
+    readonly type: 'json:boolean';
+}
+export declare namespace JsonBooleanNode {
+    function is(obj: object): obj is JsonBooleanNode;
+}
+export interface JsonNullNode extends core.AstNode, JsonBaseNode {
+    readonly type: 'json:null';
+}
+export declare namespace JsonNullNode {
+    function is(obj: object): obj is JsonNullNode;
+}
+export interface TypedJsonNode extends core.AstNode {
+    type: 'json:typed';
+    children: [JsonNode];
+    targetType: mcdoc.McdocType;
+}
+export declare namespace TypedJsonNode {
+    function is(obj: object): obj is TypedJsonNode;
+}
+export {};
 //# sourceMappingURL=index.d.ts.map

package/lib/node/index.js

@@ -1,2 +1,98 @@
-export * from './JsonAstNode.js';
+import * as core from '@spyglassmc/core';
+import { JsonStringOptions } from '../parser/index.js';
+export var JsonFileNode;
+(function (JsonFileNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj?.type === 'json:file';
+    }
+    JsonFileNode.is = is;
+})(JsonFileNode || (JsonFileNode = {}));
+export var JsonNode;
+(function (JsonNode) {
+    function is(node) {
+        return (JsonObjectNode.is(node)
+            || JsonArrayNode.is(node)
+            || JsonStringNode.is(node)
+            || JsonNumberNode.is(node)
+            || JsonBooleanNode.is(node)
+            || JsonNullNode.is(node));
+    }
+    JsonNode.is = is;
+})(JsonNode || (JsonNode = {}));
+export var JsonObjectNode;
+(function (JsonObjectNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj?.type === 'json:object';
+    }
+    JsonObjectNode.is = is;
+    function mock(range) {
+        return { type: 'json:object', range: core.Range.get(range), children: [] };
+    }
+    JsonObjectNode.mock = mock;
+})(JsonObjectNode || (JsonObjectNode = {}));
+export var JsonPairNode;
+(function (JsonPairNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'pair';
+    }
+    JsonPairNode.is = is;
+})(JsonPairNode || (JsonPairNode = {}));
+export var JsonArrayNode;
+(function (JsonArrayNode) {
+    function is(obj) {
+        return obj?.type === 'json:array';
+    }
+    JsonArrayNode.is = is;
+    function mock(range) {
+        return { type: 'json:array', range: core.Range.get(range), children: [] };
+    }
+    JsonArrayNode.mock = mock;
+})(JsonArrayNode || (JsonArrayNode = {}));
+export var JsonStringNode;
+(function (JsonStringNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj?.type === 'json:string';
+    }
+    JsonStringNode.is = is;
+    function mock(range) {
+        return { ...core.StringNode.mock(range, JsonStringOptions), type: 'json:string' };
+    }
+    JsonStringNode.mock = mock;
+})(JsonStringNode || (JsonStringNode = {}));
+export var JsonNumberNode;
+(function (JsonNumberNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'json:number';
+    }
+    JsonNumberNode.is = is;
+})(JsonNumberNode || (JsonNumberNode = {}));
+export var JsonBooleanNode;
+(function (JsonBooleanNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'json:boolean';
+    }
+    JsonBooleanNode.is = is;
+})(JsonBooleanNode || (JsonBooleanNode = {}));
+export var JsonNullNode;
+(function (JsonNullNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'json:null';
+    }
+    JsonNullNode.is = is;
+})(JsonNullNode || (JsonNullNode = {}));
+export var TypedJsonNode;
+(function (TypedJsonNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'json:typed';
+    }
+    TypedJsonNode.is = is;
+})(TypedJsonNode || (TypedJsonNode = {}));
 //# sourceMappingURL=index.js.map

package/lib/parser/array.js

@@ -1,10 +1,4 @@
 import * as core from '@spyglassmc/core';
 import { entry } from './entry.js';
-export const array = (ctx, src) => core.setType('json:array', core.list({
-    start: '[',
-    value: entry,
-    sep: ',',
-    trailingSep: false,
-    end: ']',
-}))(ctx, src);
+export const array = (ctx, src) => core.setType('json:array', core.list({ start: '[', value: entry, sep: ',', trailingSep: false, end: ']' }))(ctx, src);
 //# sourceMappingURL=array.js.map

package/lib/parser/boolean.js

@@ -3,18 +3,10 @@ import { Range } from '@spyglassmc/core';
 export const boolean = (src, _ctx) => {
     const start = src.cursor;
     if (src.trySkip('false')) {
-        return {
-            type: 'json:boolean',
-            range: Range.create(start, src),
-            value: false,
-        };
+        return { type: 'json:boolean', range: Range.create(start, src), value: false };
     }
     if (src.trySkip('true')) {
-        return {
-            type: 'json:boolean',
-            range: Range.create(start, src),
-            value: true,
-        };
+        return { type: 'json:boolean', range: Range.create(start, src), value: true };
     }
     return core.Failure;
 };

package/lib/parser/entry.js

@@ -5,31 +5,16 @@ import { null_ } from './null.js';
 import { number } from './number.js';
 import { object } from './object.js';
 import { string } from './string.js';
-const LegalNumberStart = new Set([
-    '0',
-    '1',
-    '2',
-    '3',
-    '4',
-    '5',
-    '6',
-    '7',
-    '8',
-    '9',
-    '-',
-]);
+const LegalNumberStart = new Set(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-']);
 export const entry = (src, ctx) => core.select([
     { predicate: (src) => src.tryPeek('['), parser: array },
-    {
-        predicate: (src) => src.tryPeek('false') || src.tryPeek('true'),
-        parser: boolean,
-    },
+    { predicate: (src) => src.tryPeek('false') || src.tryPeek('true'), parser: boolean },
     { predicate: (src) => src.tryPeek('null'), parser: null_ },
+    { predicate: (src) => LegalNumberStart.has(src.peek()), parser: number },
     {
-        predicate: (src) => LegalNumberStart.has(src.peek()),
-        parser: number,
+        predicate: (src) => src.tryPeek('{'),
+        parser: object,
     },
-    { predicate: (src) => src.tryPeek('{'), parser: object },
     { parser: string },
 ])(src, ctx);
 //# sourceMappingURL=entry.js.map

package/lib/parser/file.d.ts

@@ -0,0 +1,4 @@
+import * as core from '@spyglassmc/core';
+import type { JsonFileNode } from '../node/index.js';
+export declare const file: core.Parser<JsonFileNode>;
+//# sourceMappingURL=file.d.ts.map

package/lib/parser/file.js

@@ -0,0 +1,4 @@
+import * as core from '@spyglassmc/core';
+import { entry } from './entry.js';
+export const file = core.map(core.dumpErrors(entry), (res) => ({ type: 'json:file', range: res.range, children: [res] }));
+//# sourceMappingURL=file.js.map

package/lib/parser/index.d.ts

@@ -1,5 +1,8 @@
 export * from './array.js';
+export * from './boolean.js';
 export * from './entry.js';
+export * from './file.js';
+export * from './null.js';
 export * from './number.js';
 export * from './object.js';
 export * from './string.js';

package/lib/parser/index.js

@@ -1,5 +1,8 @@
 export * from './array.js';
+export * from './boolean.js';
 export * from './entry.js';
+export * from './file.js';
+export * from './null.js';
 export * from './number.js';
 export * from './object.js';
 export * from './string.js';

package/lib/parser/null.js

@@ -3,10 +3,7 @@ import { Range } from '@spyglassmc/core';
 export const null_ = (src, ctx) => {
     const start = src.cursor;
     if (src.trySkip('null')) {
-        return {
-            type: 'json:null',
-            range: Range.create(start, src),
-        };
+        return { type: 'json:null', range: Range.create(start, src) };
     }
     return core.Failure;
 };

package/lib/parser/number.js

@@ -1,24 +1,14 @@
 import * as core from '@spyglassmc/core';
 export const number = (src, ctx) => {
-    const value = core.select([
-        {
+    const value = core.select([{
             regex: /^-?(?:0|[1-9]\d*)(?!\d|[.eE])/,
-            parser: core.long({
-                pattern: /^-?(?:0|[1-9]\d*)$/,
-            }),
-        },
-        {
+            parser: core.long({ pattern: /^-?(?:0|[1-9]\d*)$/ }),
+        }, {
             parser: core.float({
                 // Regex form of the chart from https://www.json.org.
                 pattern: /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][-+]?\d+)?$/,
             }),
-        },
-    ])(src, ctx);
-    return {
-        type: 'json:number',
-        children: [value],
-        value: value,
-        range: value.range,
-    };
+        }])(src, ctx);
+    return { type: 'json:number', children: [value], value, range: value.range };
 };
 //# sourceMappingURL=number.js.map

package/lib/parser/object.js

@@ -3,13 +3,7 @@ import { entry } from './entry.js';
 import { string } from './string.js';
 export const object = (src, ctx) => core.setType('json:object', core.record({
     start: '{',
-    pair: {
-        key: string,
-        sep: ':',
-        value: entry,
-        end: ',',
-        trailingEnd: false,
-    },
+    pair: { key: string, sep: ':', value: entry, end: ',', trailingEnd: false },
     end: '}',
 }))(src, ctx);
 //# sourceMappingURL=object.js.map

package/lib/parser/string.js

@@ -1,9 +1,6 @@
 import * as core from '@spyglassmc/core';
 export const JsonStringOptions = {
-    escapable: {
-        characters: ['b', 'f', 'n', 'r', 't'],
-        unicode: true,
-    },
+    escapable: { characters: ['b', 'f', 'n', 'r', 't'], unicode: true },
     quotes: ['"'],
 };
 export const string = (src, ctx) => core.setType('json:string', core.string(JsonStringOptions))(src, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/json",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,8 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.5",
-    "@spyglassmc/locales": "0.3.5"
+    "@spyglassmc/core": "0.4.7",
+    "@spyglassmc/locales": "0.3.7",
+    "@spyglassmc/mcdoc": "0.3.10"
   }
 }

package/lib/node/JsonAstNode.d.ts

@@ -1,98 +0,0 @@
-import type { DeepReadonly, ItemNode, PairNode } from '@spyglassmc/core';
-import * as core from '@spyglassmc/core';
-export type JsonNode = JsonObjectNode | JsonArrayNode | JsonStringNode | JsonNumberNode | JsonBooleanNode | JsonNullNode;
-export type JsonRelatedNode = JsonNode | JsonPairNode | JsonItemNode;
-export declare namespace JsonNode {
-    function is(node: core.AstNode): node is JsonNode;
-    function isRelated(node: core.AstNode): node is JsonRelatedNode;
-}
-interface JsonBaseAstNode {
-    expectation?: JsonExpectation[];
-}
-export type JsonExpectation = JsonObjectExpectation | JsonArrayExpectation | JsonStringExpectation | JsonNumberExpectation | JsonBooleanExpectation;
-export declare namespace JsonExpectation {
-    function isArray(e: DeepReadonly<JsonExpectation>): e is DeepReadonly<JsonArrayExpectation>;
-    function isObject(e: DeepReadonly<JsonExpectation>): e is DeepReadonly<JsonObjectExpectation>;
-    function isString(e: DeepReadonly<JsonExpectation>): e is DeepReadonly<JsonStringExpectation>;
-}
-interface JsonBaseExpectation {
-    typedoc: string;
-}
-export interface JsonObjectExpectation extends JsonBaseExpectation {
-    readonly type: 'json:object';
-    fields?: {
-        key: string;
-        value?: JsonExpectation[];
-        opt?: boolean;
-        deprecated?: boolean;
-    }[];
-    keys?: JsonStringExpectation[];
-}
-export interface JsonObjectNode extends core.RecordBaseNode<JsonStringNode, JsonNode>, JsonBaseAstNode {
-    readonly type: 'json:object';
-}
-export declare namespace JsonObjectNode {
-    function is(obj: object | undefined): obj is JsonObjectNode;
-    function mock(range: core.RangeLike): JsonObjectNode;
-}
-export type JsonPairNode = PairNode<JsonStringNode, JsonNode>;
-export declare namespace JsonPairNode {
-    function is(obj: object): obj is JsonPairNode;
-}
-export interface JsonArrayExpectation extends JsonBaseExpectation {
-    readonly type: 'json:array';
-    items?: JsonExpectation[];
-}
-export interface JsonArrayNode extends core.ListNode<JsonNode>, JsonBaseAstNode {
-    readonly type: 'json:array';
-}
-export declare namespace JsonArrayNode {
-    function is(obj: object | undefined): obj is JsonArrayNode;
-    function mock(range: core.RangeLike): JsonArrayNode;
-}
-export type JsonItemNode = ItemNode<JsonNode>;
-export declare namespace JsonItemNode {
-    function is(obj: object): obj is JsonItemNode;
-}
-export interface JsonStringExpectation extends JsonBaseExpectation {
-    readonly type: 'json:string';
-    pool?: string[];
-}
-export declare namespace JsonStringExpectation {
-    function is(obj: object): obj is JsonStringExpectation;
-}
-export interface JsonStringNode extends core.StringBaseNode, JsonBaseAstNode {
-    readonly type: 'json:string';
-}
-export declare namespace JsonStringNode {
-    function is(obj: object | undefined): obj is JsonStringNode;
-    function mock(range: core.RangeLike): JsonStringNode;
-}
-export interface JsonNumberExpectation extends JsonBaseExpectation {
-    readonly type: 'json:number';
-}
-export interface JsonNumberNode extends JsonBaseAstNode, core.AstNode {
-    readonly type: 'json:number';
-    readonly children: [core.LongNode | core.FloatNode];
-    readonly value: core.LongNode | core.FloatNode;
-}
-export declare namespace JsonNumberNode {
-    function is(obj: object): obj is JsonNumberNode;
-}
-export interface JsonBooleanExpectation extends JsonBaseExpectation {
-    readonly type: 'json:boolean';
-}
-export interface JsonBooleanNode extends core.BooleanBaseNode, JsonBaseAstNode {
-    readonly type: 'json:boolean';
-}
-export declare namespace JsonBooleanNode {
-    function is(obj: object): obj is JsonBooleanNode;
-}
-export interface JsonNullNode extends core.AstNode, JsonBaseAstNode {
-    readonly type: 'json:null';
-}
-export declare namespace JsonNullNode {
-    function is(obj: object): obj is JsonNullNode;
-}
-export {};
-//# sourceMappingURL=JsonAstNode.d.ts.map

package/lib/node/JsonAstNode.js

@@ -1,128 +0,0 @@
-import * as core from '@spyglassmc/core';
-import { JsonStringOptions } from '../parser/index.js';
-export var JsonNode;
-(function (JsonNode) {
-    function is(node) {
-        return (JsonObjectNode.is(node) ||
-            JsonArrayNode.is(node) ||
-            JsonStringNode.is(node) ||
-            JsonNumberNode.is(node) ||
-            JsonBooleanNode.is(node) ||
-            JsonNullNode.is(node));
-    }
-    JsonNode.is = is;
-    function isRelated(node) {
-        return JsonNode.is(node) || JsonPairNode.is(node) || JsonItemNode.is(node);
-    }
-    JsonNode.isRelated = isRelated;
-})(JsonNode || (JsonNode = {}));
-export var JsonExpectation;
-(function (JsonExpectation) {
-    function isArray(e) {
-        return e.type === 'json:array';
-    }
-    JsonExpectation.isArray = isArray;
-    function isObject(e) {
-        return e.type === 'json:object';
-    }
-    JsonExpectation.isObject = isObject;
-    function isString(e) {
-        return e.type === 'json:string';
-    }
-    JsonExpectation.isString = isString;
-})(JsonExpectation || (JsonExpectation = {}));
-export var JsonObjectNode;
-(function (JsonObjectNode) {
-    /* istanbul ignore next */
-    function is(obj) {
-        return obj?.type === 'json:object';
-    }
-    JsonObjectNode.is = is;
-    function mock(range) {
-        return {
-            type: 'json:object',
-            range: core.Range.get(range),
-            children: [],
-        };
-    }
-    JsonObjectNode.mock = mock;
-})(JsonObjectNode || (JsonObjectNode = {}));
-export var JsonPairNode;
-(function (JsonPairNode) {
-    /* istanbul ignore next */
-    function is(obj) {
-        return obj.type === 'pair';
-    }
-    JsonPairNode.is = is;
-})(JsonPairNode || (JsonPairNode = {}));
-export var JsonArrayNode;
-(function (JsonArrayNode) {
-    function is(obj) {
-        return obj?.type === 'json:array';
-    }
-    JsonArrayNode.is = is;
-    function mock(range) {
-        return {
-            type: 'json:array',
-            range: core.Range.get(range),
-            children: [],
-        };
-    }
-    JsonArrayNode.mock = mock;
-})(JsonArrayNode || (JsonArrayNode = {}));
-export var JsonItemNode;
-(function (JsonItemNode) {
-    /* istanbul ignore next */
-    function is(obj) {
-        return obj.type === 'item';
-    }
-    JsonItemNode.is = is;
-})(JsonItemNode || (JsonItemNode = {}));
-export var JsonStringExpectation;
-(function (JsonStringExpectation) {
-    /* istanbul ignore next */
-    function is(obj) {
-        return obj.type === 'json:string';
-    }
-    JsonStringExpectation.is = is;
-})(JsonStringExpectation || (JsonStringExpectation = {}));
-export var JsonStringNode;
-(function (JsonStringNode) {
-    /* istanbul ignore next */
-    function is(obj) {
-        return obj?.type === 'json:string';
-    }
-    JsonStringNode.is = is;
-    function mock(range) {
-        return {
-            ...core.StringNode.mock(range, JsonStringOptions),
-            type: 'json:string',
-        };
-    }
-    JsonStringNode.mock = mock;
-})(JsonStringNode || (JsonStringNode = {}));
-export var JsonNumberNode;
-(function (JsonNumberNode) {
-    /* istanbul ignore next */
-    function is(obj) {
-        return obj.type === 'json:number';
-    }
-    JsonNumberNode.is = is;
-})(JsonNumberNode || (JsonNumberNode = {}));
-export var JsonBooleanNode;
-(function (JsonBooleanNode) {
-    /* istanbul ignore next */
-    function is(obj) {
-        return obj.type === 'json:boolean';
-    }
-    JsonBooleanNode.is = is;
-})(JsonBooleanNode || (JsonBooleanNode = {}));
-export var JsonNullNode;
-(function (JsonNullNode) {
-    /* istanbul ignore next */
-    function is(obj) {
-        return obj.type === 'json:null';
-    }
-    JsonNullNode.is = is;
-})(JsonNullNode || (JsonNullNode = {}));
-//# sourceMappingURL=JsonAstNode.js.map