@spyglassmc/json 0.3.1 → 0.3.3

package/lib/checker/JsonChecker.d.ts

@@ -4,5 +4,5 @@ export interface JsonCheckerContext extends CheckerContext {
     context: string;
     depth?: number;
 }
-export declare type JsonChecker = (node: JsonNode, ctx: JsonCheckerContext) => void;
+export type JsonChecker = (node: JsonNode, ctx: JsonCheckerContext) => void;
 //# sourceMappingURL=JsonChecker.d.ts.map

package/lib/checker/primitives/list.d.ts

@@ -1,7 +1,7 @@
 import type { JsonNode } from '../../node/index.js';
 import type { JsonChecker, JsonCheckerContext } from '../JsonChecker.js';
 export declare function listOf(checker: JsonChecker): JsonChecker;
-declare type UniqueListOptions = {
+type UniqueListOptions = {
     items?: (node: JsonNode) => [string | undefined, JsonNode];
     report?: (node: JsonNode, ctx: JsonCheckerContext) => unknown;
 };

package/lib/checker/primitives/list.js

@@ -5,26 +5,30 @@ export function listOf(checker) {
     return (node, ctx) => {
         node.expectation = [{ type: 'json:array', typedoc: 'Array' }];
         if (!ctx.depth || ctx.depth <= 0) {
+            ;
             node.expectation[0].items = expectation(checker, ctx);
         }
         if (!JsonArrayNode.is(node)) {
             ctx.err.report(localize('expected', localize('array')), node);
         }
         else {
-            node.children.filter(e => e.value)
-                .forEach(e => checker(e.value, ctx));
+            node.children
+                .filter((e) => e.value)
+                .forEach((e) => checker(e.value, ctx));
         }
     };
 }
 export function uniqueListOf(checker, options = {}) {
-    const getItem = (options.items ?? (node => [JsonStringNode.is(node) ? node.value : undefined, node]));
-    const reporter = options.report ?? ((node, ctx) => ctx.err.report(localize('json.checker.item.duplicate'), node, 2 /* ErrorSeverity.Warning */));
+    const getItem = options.items ??
+        ((node) => [JsonStringNode.is(node) ? node.value : undefined, node]);
+    const reporter = options.report ??
+        ((node, ctx) => ctx.err.report(localize('json.checker.item.duplicate'), node, 2 /* ErrorSeverity.Warning */));
     return (node, ctx) => {
         listOf(checker)(node, ctx);
         if (JsonArrayNode.is(node)) {
             const items = new Map();
             const duplicates = new Set();
-            node.children.forEach(c => {
+            node.children.forEach((c) => {
                 if (!c.value)
                     return;
                 const [value, item] = getItem(c.value);
@@ -37,7 +41,7 @@ export function uniqueListOf(checker, options = {}) {
                 }
                 items.set(value, item);
             });
-            duplicates.forEach(node => reporter(node, ctx));
+            duplicates.forEach((node) => reporter(node, ctx));
         }
     };
 }

package/lib/checker/primitives/number.js

@@ -2,12 +2,18 @@ import { localize } from '@spyglassmc/locales';
 import { JsonNumberNode } from '../../node/index.js';
 const number = (type) => (min, max) => {
     return (node, ctx) => {
-        const typedoc = 'Number' + (min === undefined && max === undefined ? '' : `(${min ?? '-∞'}, ${max ?? '+∞'})`);
+        const typedoc = 'Number' +
+            (min === undefined && max === undefined
+                ? ''
+                : `(${min ?? '-∞'}, ${max ?? '+∞'})`);
         node.expectation = [{ type: 'json:number', typedoc }];
-        if (!JsonNumberNode.is(node) || (type === 'integer' && !Number.isInteger(node.value))) {
+        if (!JsonNumberNode.is(node) ||
+            (type === 'integer' && !Number.isInteger(node.value))) {
             ctx.err.report(localize('expected', localize(type)), node);
         }
-        else if (min !== undefined && max !== undefined && (node.value < min || node.value > max)) {
+        else if (min !== undefined &&
+            max !== undefined &&
+            (node.value < min || node.value > max)) {
             ctx.err.report(localize('expected', localize('number.between', min, max)), node);
         }
         else if (min !== undefined && node.value < min) {

package/lib/checker/primitives/object.d.ts

@@ -1,19 +1,19 @@
 import type { PairNode } from '@spyglassmc/core';
 import type { JsonNode, JsonStringNode } from '../../node/index.js';
 import type { JsonChecker, JsonCheckerContext } from '../JsonChecker.js';
-declare type JsonValue = string | number | boolean | null | JsonValue[] | {
+type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };
-declare type ComplexProperty = {
+type ComplexProperty = {
     checker: JsonChecker;
     opt?: boolean;
     def?: JsonValue;
     deprecated?: boolean;
     context?: string;
 };
-declare type CheckerProperty = JsonChecker | ComplexProperty;
-declare type CheckerRecord = Record<string, CheckerProperty | undefined>;
-declare type ObjectCheckerOptions = {
+type CheckerProperty = JsonChecker | ComplexProperty;
+type CheckerRecord = Record<string, CheckerProperty | undefined>;
+type ObjectCheckerOptions = {
     allowUnknownProperties?: boolean;
 };
 export declare function object(): JsonChecker;

package/lib/checker/primitives/object.js

@@ -10,36 +10,45 @@ export function object(keys, values, options = {}) {
         node.expectation = [{ type: 'json:object', typedoc: 'Object' }];
         if (!ctx.depth || ctx.depth <= 0) {
             if (Array.isArray(keys) && values) {
-                const fields = keys.map(key => [key, values(key, ctx)]).filter(([_, v]) => v !== undefined);
-                node.expectation[0].fields = fields.map(([key, prop]) => {
+                const fields = keys
+                    .map((key) => [key, values(key, ctx)])
+                    .filter(([_, v]) => v !== undefined);
+                node.expectation[0].fields = fields
+                    .map(([key, prop]) => {
                     return {
                         key,
                         value: expectation(isComplex(prop) ? prop.checker : prop, ctx),
-                        ...isComplex(prop) && (prop.opt || prop.deprecated) ? { opt: true } : {},
-                        ...isComplex(prop) && prop.deprecated ? { deprecated: true } : {},
+                        ...(isComplex(prop) && (prop.opt || prop.deprecated)
+                            ? { opt: true }
+                            : {}),
+                        ...(isComplex(prop) && prop.deprecated
+                            ? { deprecated: true }
+                            : {}),
                     };
                 });
             }
             else if (typeof keys === 'function' && values) {
-                node.expectation[0].keys = expectation(keys, ctx)
-                    ?.filter(JsonStringExpectation.is);
+                ;
+                node.expectation[0].keys = expectation(keys, ctx)?.filter(JsonStringExpectation.is);
             }
         }
         if (!JsonObjectNode.is(node)) {
             ctx.err.report(localize('expected', localize('object')), node);
         }
         else if (Array.isArray(keys) && values) {
-            const givenKeys = node.children.map(n => n.key?.value);
-            keys.forEach(k => {
+            const givenKeys = node.children.map((n) => n.key?.value);
+            keys.forEach((k) => {
                 const value = values(k, ctx);
-                if (!value || isComplex(value) && (value.opt || value.deprecated)) {
+                if (!value || (isComplex(value) && (value.opt || value.deprecated))) {
                     return;
                 }
                 if (!givenKeys.includes(k)) {
                     ctx.err.report(localize('json.checker.property.missing', localeQuote(k)), Range.create(node.range.start, node.range.start + 1));
                 }
             });
-            node.children.filter(p => p.key).forEach(prop => {
+            node.children
+                .filter((p) => p.key)
+                .forEach((prop) => {
                 const key = prop.key.value;
                 const value = values(key, ctx);
                 if (!value || !keys.includes(key)) {
@@ -51,9 +60,12 @@ export function object(keys, values, options = {}) {
                 if (isComplex(value) && value.deprecated) {
                     ctx.err.report(localize('json.checker.property.deprecated', localeQuote(key)), prop.key, 0 /* ErrorSeverity.Hint */, { deprecated: true });
                 }
-                const context = ctx.context + (isComplex(value) && value.context ? `.${value.context}` : '');
+                const context = ctx.context +
+                    (isComplex(value) && value.context ? `.${value.context}` : '');
                 const doc = localize(`json.doc.${context}`);
-                const propNode = prop.value !== undefined ? prop.value : { type: 'json:null', range: Range.create(0) };
+                const propNode = prop.value !== undefined
+                    ? prop.value
+                    : { type: 'json:null', range: Range.create(0) };
                 const checker = isComplex(value) ? value.checker : value;
                 try {
                     checker(propNode, { ...ctx, context: `${context}.${key}` });
@@ -63,12 +75,19 @@ export function object(keys, values, options = {}) {
                     ctx.logger.error(`Checking "${key}" at ${pos.line}:${pos.character} in "${ctx.doc.uri}"`, e);
                 }
                 const defaultValue = isComplex(value) ? value.def : undefined;
-                const typedoc = propNode.expectation?.map(e => e.typedoc).join(' | ');
-                prop.key.hover = `\`\`\`typescript\n${context}.${key}: ${typedoc}\n\`\`\`${doc || defaultValue !== undefined ? '\n******\n ' : ''}${doc}${defaultValue !== undefined ? `\n\`@default\` ${JSON.stringify(defaultValue)}` : ''}`;
+                const typedoc = propNode.expectation
+                    ?.map((e) => e.typedoc)
+                    .join(' | ');
+                prop.key.hover =
+                    `\`\`\`typescript\n${context}.${key}: ${typedoc}\n\`\`\`${doc || defaultValue !== undefined ? '\n******\n ' : ''}${doc}${defaultValue !== undefined
+                        ? `\n\`@default\` ${JSON.stringify(defaultValue)}`
+                        : ''}`;
             });
         }
         else if (typeof keys === 'function' && values) {
-            node.children.filter(p => p.key).forEach(prop => {
+            node.children
+                .filter((p) => p.key)
+                .forEach((prop) => {
                 keys(prop.key, ctx);
                 if (prop.value !== undefined) {
                     const value = values(prop.key.value, ctx);
@@ -104,12 +123,15 @@ export function dispatch(arg1, arg2) {
             ctx.err.report(localize('expected', localize('object')), node);
         }
         else if (arg2) {
-            const dispatcherIndex = node.children.findIndex(p => p.key?.value === arg1);
+            const dispatcherIndex = node.children.findIndex((p) => p.key?.value === arg1);
             const dispatcher = node.children[dispatcherIndex];
-            const value = dispatcher?.value?.type === 'json:string' ? dispatcher.value.value : undefined;
+            const value = dispatcher?.value?.type === 'json:string'
+                ? dispatcher.value.value
+                : undefined;
             arg2(value, node.children, ctx)(node, ctx);
         }
         else {
+            ;
             arg1(node.children, ctx)(node, ctx);
         }
     };
@@ -122,7 +144,7 @@ export function pick(value, cases) {
     if (properties === undefined) {
         return {};
     }
-    Object.keys(properties).forEach(key => {
+    Object.keys(properties).forEach((key) => {
         const p = properties[key];
         if (p === undefined)
             return;
@@ -145,30 +167,33 @@ export function when(value, values, properties, notProperties = {}) {
     return properties;
 }
 export function extract(value, children) {
-    const node = children?.find(p => p.key?.value === value);
+    const node = children?.find((p) => p.key?.value === value);
     return node?.value?.type === 'json:string' ? node.value.value : undefined;
 }
 export function extractNested(wrap, value, children) {
-    const wrapper = children?.find(p => p.key?.value === wrap);
+    const wrapper = children?.find((p) => p.key?.value === wrap);
     if (wrapper?.value?.type !== 'json:object')
         return undefined;
-    const node = wrapper.children?.find(p => p.key?.value === value);
+    const node = wrapper.children?.find((p) => p.key?.value ===
+        value);
     return node?.type === 'json:string' ? node.value : undefined;
 }
 export function extractStringArray(value, children) {
-    const node = children?.find(p => p.key?.value === value);
-    return node?.value?.type === 'json:array' && node.value.children?.every((n) => n.value?.type === 'json:string')
-        ? node.value.children.map(n => n.value.value)
+    const node = children?.find((p) => p.key?.value === value);
+    return node?.value?.type === 'json:array' &&
+        node.value.children?.every((n) => n.value?.type === 'json:string')
+        ? node.value.children.map((n) => n.value.value)
         : undefined;
 }
 export function having(node, ctx, cases) {
-    const givenKeys = new Set(JsonObjectNode.is(node)
-        ? node.children.map(n => n.key?.value) : []);
-    const key = Object.keys(cases).find(c => givenKeys.has(c));
+    const givenKeys = new Set(JsonObjectNode.is(node) ? node.children.map((n) => n.key?.value) : []);
+    const key = Object.keys(cases).find((c) => givenKeys.has(c));
     if (key === undefined) {
         ctx.err.report(localize('json.checker.property.missing', Object.keys(cases)), Range.create(node.range.start, node.range.start + 1));
-        return Object.fromEntries(Object.entries(cases)
-            .map(([k, v]) => [k, opt(typeof v === 'function' ? any() : v[k] ?? any())]));
+        return Object.fromEntries(Object.entries(cases).map(([k, v]) => [
+            k,
+            opt(typeof v === 'function' ? any() : v[k] ?? any()),
+        ]));
     }
     const c = cases[key];
     return typeof c === 'function' ? c() : c;

package/lib/checker/primitives/string.js

@@ -14,7 +14,9 @@ export function literal(value) {
 }
 export function string(name, parser, checker, expectation) {
     return (node, ctx) => {
-        node.expectation = [{ type: 'json:string', typedoc: typedoc(name), ...expectation }];
+        node.expectation = [
+            { type: 'json:string', typedoc: typedoc(name), ...expectation },
+        ];
         if (!JsonStringNode.is(node)) {
             ctx.err.report(localize('expected', localize('string')), node);
         }
@@ -40,8 +42,10 @@ function typedoc(id) {
     if (typeof id === 'string') {
         return `String("${id}")`;
     }
-    return id.slice(0, 10).map(e => `"${e}"`).join(' | ')
-        + (id.length > 10 ? ' | ...' : '');
+    return (id
+        .slice(0, 10)
+        .map((e) => `"${e}"`)
+        .join(' | ') + (id.length > 10 ? ' | ...' : ''));
 }
 export const simpleString = string();
 //# sourceMappingURL=string.js.map

package/lib/checker/primitives/util.d.ts

@@ -3,7 +3,7 @@ import type { JsonExpectation, JsonNode } from '../../node/index.js';
 import type { JsonChecker, JsonCheckerContext } from '../JsonChecker.js';
 export declare function ref(checker: () => JsonChecker): JsonChecker;
 export declare function as(context: string, checker: JsonChecker): JsonChecker;
-export declare type AttemptResult = {
+export type AttemptResult = {
     totalErrorSpan: number;
     maxSeverity: ErrorSeverity;
     expectation?: JsonExpectation[];

package/lib/checker/primitives/util.js

@@ -21,11 +21,11 @@ export function attempt(checker, node, ctx) {
     const tempExpectation = node.expectation;
     StateProxy.undoChanges(node);
     const totalErrorSpan = tempCtx.err.errors
-        .map(e => e.range.end - e.range.start)
+        .map((e) => e.range.end - e.range.start)
         .reduce((a, b) => a + b, 0);
     return {
         totalErrorSpan,
-        maxSeverity: Math.max(...tempCtx.err.errors.map(e => e.severity)),
+        maxSeverity: Math.max(...tempCtx.err.errors.map((e) => e.severity)),
         expectation: tempExpectation,
         updateNodeAndCtx: () => {
             ctx.err.absorb(tempCtx.err);
@@ -40,13 +40,15 @@ export function any(checkers = []) {
             return;
         }
         const attempts = checkers
-            .map(checker => attempt(checker, node, ctx))
-            .sort((a, b) => a.maxSeverity - b.maxSeverity || a.totalErrorSpan - b.totalErrorSpan);
-        const sameTypeAttempts = attempts
-            .filter(a => a.expectation?.map(e => e.type).includes(node.type));
-        const allExpectations = attempts.filter(a => a.expectation).flatMap(a => a.expectation);
+            .map((checker) => attempt(checker, node, ctx))
+            .sort((a, b) => a.maxSeverity - b.maxSeverity ||
+            a.totalErrorSpan - b.totalErrorSpan);
+        const sameTypeAttempts = attempts.filter((a) => a.expectation?.map((e) => e.type).includes(node.type));
+        const allExpectations = attempts
+            .filter((a) => a.expectation)
+            .flatMap((a) => a.expectation);
         if (sameTypeAttempts.length === 0) {
-            const allowedTypes = allExpectations.map(e => localize(e.type.slice(5)));
+            const allowedTypes = allExpectations.map((e) => localize(e.type.slice(5)));
             ctx.err.report(localize('expected', arrayToMessage(allowedTypes, false)), node);
         }
         else {
@@ -56,7 +58,10 @@ export function any(checkers = []) {
     };
 }
 export function expectation(checker, ctx) {
-    const node = StateProxy.create({ type: 'json:null', range: Range.create(0) });
+    const node = StateProxy.create({
+        type: 'json:null',
+        range: Range.create(0),
+    });
     const tempCtx = {
         ...ctx,
         err: new ErrorReporter(),

package/lib/colorizer/index.js

@@ -1,9 +1,9 @@
 import * as core from '@spyglassmc/core';
 import { ColorToken } from '@spyglassmc/core';
-export const boolean = node => {
+export const boolean = (node) => {
     return [ColorToken.create(node, 'literal')];
 };
-export const null_ = node => {
+export const null_ = (node) => {
     return [ColorToken.create(node, 'literal')];
 };
 export const object = (node, ctx) => {

package/lib/completer/index.js

@@ -15,8 +15,9 @@ export const entry = (node, ctx) => {
 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)));
+            return unique(record.expectation
+                .filter(JsonExpectation.isObject)
+                .flatMap((e) => objectCompletion(range, record, e, ctx, insertValue, insertComma, pair?.key?.value)));
         }
         return [];
     },
@@ -25,10 +26,11 @@ export const object = core.completer.record({
             return core.completer.dispatch(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)));
+            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)));
         }
         return [];
     },
@@ -41,37 +43,42 @@ export const array = (node, ctx) => {
     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)));
+    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));
+    return ['false', 'true'].map((v) => simpleCompletion(node, v));
 };
 const string = (node, ctx) => {
     if (node.children?.length) {
         return core.completer.string(node, ctx);
     }
     if (node.expectation) {
-        return unique(node.expectation.filter(JsonExpectation.isString)
-            .flatMap(e => stringCompletion(node, e, ctx)));
+        return unique(node.expectation
+            .filter(JsonExpectation.isString)
+            .flatMap((e) => stringCompletion(node, e, ctx)));
     }
     return [];
 };
 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));
+        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 => ({
+        return expectation.keys.flatMap((e) => stringCompletion(range, e, ctx).map((c) => ({
             ...c,
-            ...insertValue ? { insertText: `${c.insertText}: ${insertComma ? ',' : ''}` } : {},
+            ...(insertValue
+                ? { insertText: `${c.insertText}: ${insertComma ? ',' : ''}` }
+                : {}),
         })));
     }
     return [];
@@ -80,7 +87,7 @@ 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(' | '),
+        detail: field.value?.map((e) => e.typedoc).join(' | '),
         sortText: `${field.deprecated ? 2 : field.opt ? 1 : 0}${field.key}`,
         deprecated: field.deprecated,
         filterText: `"${field.key}"`,
@@ -88,7 +95,7 @@ function fieldCompletion(range, field, insertValue, insertComma) {
     });
 }
 function valueCompletion(range, expectation, ctx) {
-    return unique(expectation.flatMap(e => {
+    return unique(expectation.flatMap((e) => {
         switch (e.type) {
             case 'json:object':
             case 'json:array':
@@ -96,7 +103,7 @@ function valueCompletion(range, expectation, ctx) {
             case 'json:string':
                 return stringCompletion(ctx.offset, e, ctx);
             case 'json:boolean':
-                return ['false', 'true'].map(v => simpleCompletion(range, v));
+                return ['false', 'true'].map((v) => simpleCompletion(range, v));
             case 'json:number':
                 return [simpleCompletion(range, '0')];
         }
@@ -104,7 +111,7 @@ function valueCompletion(range, expectation, ctx) {
 }
 function stringCompletion(range, expectation, ctx) {
     if (Array.isArray(expectation.pool)) {
-        return expectation.pool.map(v => CompletionItem.create(v, range, {
+        return expectation.pool.map((v) => CompletionItem.create(v, range, {
             kind: 12 /* CompletionKind.Value */,
             filterText: `"${v}"`,
             insertText: `"${v}"`,
@@ -121,7 +128,7 @@ function simpleCompletion(range, value) {
 function unique(completions) {
     const ans = [];
     const labels = new Set();
-    completions.forEach(c => {
+    completions.forEach((c) => {
         if (!labels.has(c.label)) {
             labels.add(c.label);
             ans.push(c);

package/lib/formatter/index.js

@@ -3,8 +3,9 @@ import { indentFormatter } from '@spyglassmc/core';
 const array = (node, ctx) => {
     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 values = node.children.map((child) => {
+        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()}]`;
@@ -12,9 +13,10 @@ const array = (node, ctx) => {
 const object = (node, ctx) => {
     if (node.children.length === 0)
         return '{}';
-    const fields = node.children.map(child => {
+    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/node/JsonAstNode.d.ts

@@ -1,7 +1,7 @@
 import type { DeepReadonly, ItemNode, PairNode } from '@spyglassmc/core';
 import * as core from '@spyglassmc/core';
-export declare type JsonNode = JsonObjectNode | JsonArrayNode | JsonStringNode | JsonNumberNode | JsonBooleanNode | JsonNullNode;
-export declare type JsonRelatedNode = JsonNode | JsonPairNode | JsonItemNode;
+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;
@@ -9,7 +9,7 @@ export declare namespace JsonNode {
 interface JsonBaseAstNode {
     expectation?: JsonExpectation[];
 }
-export declare type JsonExpectation = JsonObjectExpectation | JsonArrayExpectation | JsonStringExpectation | JsonNumberExpectation | JsonBooleanExpectation;
+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>;
@@ -35,7 +35,7 @@ export declare namespace JsonObjectNode {
     function is(obj: object | undefined): obj is JsonObjectNode;
     function mock(range: core.RangeLike): JsonObjectNode;
 }
-export declare type JsonPairNode = PairNode<JsonStringNode, JsonNode>;
+export type JsonPairNode = PairNode<JsonStringNode, JsonNode>;
 export declare namespace JsonPairNode {
     function is(obj: object): obj is JsonPairNode;
 }
@@ -50,7 +50,7 @@ export declare namespace JsonArrayNode {
     function is(obj: object | undefined): obj is JsonArrayNode;
     function mock(range: core.RangeLike): JsonArrayNode;
 }
-export declare type JsonItemNode = ItemNode<JsonNode>;
+export type JsonItemNode = ItemNode<JsonNode>;
 export declare namespace JsonItemNode {
     function is(obj: object): obj is JsonItemNode;
 }

package/lib/node/JsonAstNode.js

@@ -12,9 +12,7 @@ export var JsonNode;
     }
     JsonNode.is = is;
     function isRelated(node) {
-        return (JsonNode.is(node) ||
-            JsonPairNode.is(node) ||
-            JsonItemNode.is(node));
+        return JsonNode.is(node) || JsonPairNode.is(node) || JsonItemNode.is(node);
     }
     JsonNode.isRelated = isRelated;
 })(JsonNode || (JsonNode = {}));

package/lib/parser/entry.js

@@ -5,15 +5,33 @@ 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 function json(dumpErrors = false) {
     return (src, ctx) => {
         const result = core.select([
-            { predicate: src => src.tryPeek('['), parser: array },
-            { 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 => src.tryPeek('{'), parser: object },
+            { predicate: (src) => src.tryPeek('['), parser: array },
+            {
+                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) => src.tryPeek('{'), parser: object },
             { parser: string },
         ])(src, ctx);
         if (dumpErrors) {

package/lib/parser/object.js

@@ -4,7 +4,13 @@ import { string } from './string.js';
 export const object = (src, ctx) => {
     return 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);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/json",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,7 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.0",
-    "@spyglassmc/locales": "0.3.0"
+    "@spyglassmc/core": "0.4.2",
+    "@spyglassmc/locales": "0.3.2"
   }
 }