@spyglassmc/json 0.1.0

package/lib/completer/index.d.ts

@@ -0,0 +1,9 @@
+import type { Completer, MetaRegistry } from '@spyglassmc/core';
+import type { JsonArrayNode, JsonBooleanNode, JsonNode, JsonObjectNode } from '../node';
+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;
+//# sourceMappingURL=index.d.ts.map

package/lib/completer/index.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = exports.boolean = exports.array = exports.object = exports.entry = exports.JsonTriggerCharacters = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const core_1 = require("@spyglassmc/core");
+const node_1 = require("../node");
+exports.JsonTriggerCharacters = ['\n', ':', '"'];
+const SIMPLE_SNIPPETS = {
+    'json:object': '{$1}',
+    'json:array': '[$1]',
+    'json:string': '"$1"',
+    'json:boolean': '${1|false,true|}',
+    'json:number': '${1:0}',
+};
+const entry = (node, ctx) => {
+    return core.completer.dispatch(node, ctx);
+};
+exports.entry = entry;
+exports.object = core.completer.record({
+    key: (record, pair, ctx, range, insertValue, insertComma) => {
+        if (record.expectation) {
+            return unique(record.expectation.filter(node_1.JsonExpectation.isObject)
+                .flatMap(e => objectCompletion(range, record, e, ctx, insertValue, insertComma, pair?.key?.value)));
+        }
+        return [];
+    },
+    value: (record, pair, ctx) => {
+        if (pair.value && !core_1.Range.isEmpty(pair.value)) {
+            return core.completer.dispatch(pair.value, ctx);
+        }
+        if (record.expectation) {
+            return unique(record.expectation.filter(node_1.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 [];
+    },
+});
+const array = (node, ctx) => {
+    const index = core.binarySearch(node.children, ctx.offset, (n, o) => n.sep
+        ? core_1.Range.compareOffset(core_1.Range.translate(n, 0, -1), o, true)
+        : core_1.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 && core_1.Range.contains(core_1.Range.translate(node, 1, -1), ctx.offset, true)) {
+        return unique(node.expectation.filter(node_1.JsonExpectation.isArray)
+            .filter(e => e.items)
+            .flatMap(e => valueCompletion(ctx.offset, e.items, ctx)));
+    }
+    return [];
+};
+exports.array = array;
+const boolean = (node) => {
+    return ['false', 'true'].map(v => simpleCompletion(node, v));
+};
+exports.boolean = boolean;
+const string = (node, ctx) => {
+    if (node.children?.length) {
+        return core.completer.string(node, ctx);
+    }
+    if (node.expectation) {
+        return unique(node.expectation.filter(node_1.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));
+    }
+    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 core_1.CompletionItem.create(field.key, range, {
+        kind: 10 /* 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 stringCompletion(range, expectation, ctx) {
+    if (Array.isArray(expectation.pool)) {
+        return expectation.pool.map(v => core_1.CompletionItem.create(v, range, {
+            kind: 12 /* Value */,
+            filterText: `"${v}"`,
+            insertText: `"${v}"`,
+        }));
+    }
+    return [simpleCompletion(range, SIMPLE_SNIPPETS[expectation.type])];
+}
+function simpleCompletion(range, value) {
+    return core_1.CompletionItem.create(value.replace('$1', ''), range, {
+        kind: 12 /* 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;
+}
+function register(meta) {
+    meta.registerCompleter('json:entry', exports.entry);
+    meta.registerCompleter('json:array', exports.array);
+    meta.registerCompleter('json:boolean', exports.boolean);
+    meta.registerCompleter('json:object', exports.object);
+    meta.registerCompleter('json:string', string);
+}
+exports.register = register;
+//# sourceMappingURL=index.js.map

package/lib/formatter/index.d.ts

@@ -0,0 +1,3 @@
+import type { MetaRegistry } from '../../../core/lib';
+export declare function register(meta: MetaRegistry): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/formatter/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const lib_1 = require("../../../core/lib");
+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, (0, lib_1.indentFormatter)(ctx));
+        return `${ctx.indent(1)}${value ?? ''}`;
+    });
+    return `[\n${values.join(',\n')}\n${ctx.indent()}]`;
+};
+const object = (node, ctx) => {
+    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, (0, lib_1.indentFormatter)(ctx));
+        return `${ctx.indent(1)}${key ?? ''}: ${value ?? ''}`;
+    });
+    return `{\n${fields.join(',\n')}\n${ctx.indent()}}`;
+};
+function register(meta) {
+    meta.registerFormatter('json:array', array);
+    meta.registerFormatter('json:boolean', core.formatter.boolean);
+    meta.registerFormatter('json:null', () => 'null');
+    meta.registerFormatter('json:number', core.formatter.float);
+    meta.registerFormatter('json:object', object);
+    meta.registerFormatter('json:string', core.formatter.string);
+}
+exports.register = register;
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import type * as core from '@spyglassmc/core';
+export * as checker from './checker';
+export * as colorizer from './colorizer';
+export * as completer from './completer';
+export * as formatter from './formatter';
+export * from './node';
+export * as parser from './parser';
+export declare const initialize: core.ProjectInitializer;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/* istanbul ignore file */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = exports.parser = exports.formatter = exports.completer = exports.colorizer = exports.checker = void 0;
+const colorizer = __importStar(require("./colorizer"));
+const completer = __importStar(require("./completer"));
+const formatter = __importStar(require("./formatter"));
+const parser = __importStar(require("./parser"));
+exports.checker = __importStar(require("./checker"));
+exports.colorizer = __importStar(require("./colorizer"));
+exports.completer = __importStar(require("./completer"));
+exports.formatter = __importStar(require("./formatter"));
+__exportStar(require("./node"), exports);
+exports.parser = __importStar(require("./parser"));
+const initialize = ({ meta }) => {
+    meta.registerLanguage('json', {
+        extensions: ['.json', '.mcmeta'],
+        triggerCharacters: completer.JsonTriggerCharacters,
+        parser: parser.entry,
+    });
+    meta.registerParser('json:entry', parser.entry);
+    colorizer.register(meta);
+    completer.register(meta);
+    formatter.register(meta);
+};
+exports.initialize = initialize;
+//# sourceMappingURL=index.js.map

package/lib/node/JsonAstNode.d.ts

@@ -0,0 +1,97 @@
+import type { 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 declare namespace JsonNode {
+    function is(node: core.AstNode): node is JsonNode;
+    function isRelated(node: core.AstNode): node is JsonRelatedNode;
+}
+interface JsonBaseAstNode {
+    expectation?: JsonExpectation[];
+}
+export declare type JsonExpectation = JsonObjectExpectation | JsonArrayExpectation | JsonStringExpectation | JsonNumberExpectation | JsonBooleanExpectation;
+export declare namespace JsonExpectation {
+    function isArray(e: JsonExpectation): e is JsonArrayExpectation;
+    function isObject(e: JsonExpectation): e is JsonObjectExpectation;
+    function isString(e: JsonExpectation): e is 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 declare 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 declare 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 core.FloatBaseNode, JsonBaseAstNode {
+    readonly type: 'json:number';
+    readonly value: number;
+}
+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

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonNullNode = exports.JsonBooleanNode = exports.JsonNumberNode = exports.JsonStringNode = exports.JsonStringExpectation = exports.JsonItemNode = exports.JsonArrayNode = exports.JsonPairNode = exports.JsonObjectNode = exports.JsonExpectation = exports.JsonNode = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const parser_1 = require("../parser");
+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 = exports.JsonNode || (exports.JsonNode = {}));
+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 = exports.JsonExpectation || (exports.JsonExpectation = {}));
+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 = exports.JsonObjectNode || (exports.JsonObjectNode = {}));
+var JsonPairNode;
+(function (JsonPairNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'pair';
+    }
+    JsonPairNode.is = is;
+})(JsonPairNode = exports.JsonPairNode || (exports.JsonPairNode = {}));
+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 = exports.JsonArrayNode || (exports.JsonArrayNode = {}));
+var JsonItemNode;
+(function (JsonItemNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'item';
+    }
+    JsonItemNode.is = is;
+})(JsonItemNode = exports.JsonItemNode || (exports.JsonItemNode = {}));
+var JsonStringExpectation;
+(function (JsonStringExpectation) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'json:string';
+    }
+    JsonStringExpectation.is = is;
+})(JsonStringExpectation = exports.JsonStringExpectation || (exports.JsonStringExpectation = {}));
+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, parser_1.JsonStringOptions),
+            type: 'json:string',
+        };
+    }
+    JsonStringNode.mock = mock;
+})(JsonStringNode = exports.JsonStringNode || (exports.JsonStringNode = {}));
+var JsonNumberNode;
+(function (JsonNumberNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'json:number';
+    }
+    JsonNumberNode.is = is;
+})(JsonNumberNode = exports.JsonNumberNode || (exports.JsonNumberNode = {}));
+var JsonBooleanNode;
+(function (JsonBooleanNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'json:boolean';
+    }
+    JsonBooleanNode.is = is;
+})(JsonBooleanNode = exports.JsonBooleanNode || (exports.JsonBooleanNode = {}));
+var JsonNullNode;
+(function (JsonNullNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'json:null';
+    }
+    JsonNullNode.is = is;
+})(JsonNullNode = exports.JsonNullNode || (exports.JsonNullNode = {}));
+//# sourceMappingURL=JsonAstNode.js.map

package/lib/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './JsonAstNode';
+//# sourceMappingURL=index.d.ts.map

package/lib/node/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./JsonAstNode"), exports);
+//# sourceMappingURL=index.js.map

package/lib/parser/array.d.ts

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

package/lib/parser/array.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.array = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const entry_1 = require("./entry");
+const array = (src, ctx) => {
+    const parser = core.list({
+        start: '[',
+        value: entry_1.entry,
+        sep: ',',
+        trailingSep: false,
+        end: ']',
+    });
+    const ans = parser(src, ctx);
+    ans.type = 'json:array';
+    return ans;
+};
+exports.array = array;
+//# sourceMappingURL=array.js.map

package/lib/parser/boolean.d.ts

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

package/lib/parser/boolean.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const core_1 = require("@spyglassmc/core");
+const boolean = (src, ctx) => {
+    const start = src.cursor;
+    if (src.trySkip('false')) {
+        return {
+            type: 'json:boolean',
+            range: core_1.Range.create(start, src),
+            value: false,
+        };
+    }
+    if (src.trySkip('true')) {
+        return {
+            type: 'json:boolean',
+            range: core_1.Range.create(start, src),
+            value: true,
+        };
+    }
+    return core.Failure;
+};
+exports.boolean = boolean;
+//# sourceMappingURL=boolean.js.map

package/lib/parser/entry.d.ts

@@ -0,0 +1,5 @@
+import * as core from '@spyglassmc/core';
+import type { JsonNode } from '../node';
+export declare function json(dumpErrors?: boolean): core.Parser<JsonNode>;
+export declare const entry: core.Parser<JsonNode>;
+//# sourceMappingURL=entry.d.ts.map