@spyglassmc/core 0.1.0

package/lib/processor/colorizer/Colorizer.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorTokenModifiers = exports.ColorTokenTypes = exports.ColorToken = void 0;
+const source_1 = require("../../source");
+var ColorToken;
+(function (ColorToken) {
+    /* istanbul ignore next */
+    function create(range, type, modifiers) {
+        return {
+            range: source_1.Range.get(range),
+            type,
+            modifiers,
+        };
+    }
+    ColorToken.create = create;
+    /**
+     * @returns An array of color tokens that cover the whole range of `targetRange`, with gaps in `tokens` filled
+     * with tokens created from the specified `type` and `modifiers`.
+     */
+    function fillGap(tokens, targetRange, type, modifiers) {
+        const ans = [];
+        let nextStart = Math.min(targetRange.start, tokens[0]?.range.start ?? Infinity);
+        for (const t of tokens) {
+            if (t.range.start > nextStart) {
+                ans.push(ColorToken.create(source_1.Range.create(nextStart, t.range.start), type, modifiers));
+            }
+            ans.push(t);
+            nextStart = t.range.end;
+        }
+        if (nextStart < targetRange.end) {
+            ans.push(ColorToken.create(source_1.Range.create(nextStart, targetRange.end), type, modifiers));
+        }
+        return ans;
+    }
+    ColorToken.fillGap = fillGap;
+})(ColorToken = exports.ColorToken || (exports.ColorToken = {}));
+// Built-in LSP semantic tokens: https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#textDocument_semanticTokens
+exports.ColorTokenTypes = Object.freeze([
+    'comment',
+    'enum',
+    'enumMember',
+    'function',
+    'keyword',
+    'modifier',
+    'number',
+    'operator',
+    'property',
+    'string',
+    'struct',
+    'type',
+    'type',
+    'variable',
+    // Below are custom types.
+    'error',
+    'literal',
+    'operator',
+    'resourceLocation',
+    'vector',
+]);
+exports.ColorTokenModifiers = Object.freeze([
+    'declaration',
+    'defaultLibrary',
+    'definition',
+    'deprecated',
+    'documentation',
+    'modification',
+    'readonly',
+    // Below are custom modifiers.
+]);
+//# sourceMappingURL=Colorizer.js.map

package/lib/processor/colorizer/builtin.d.ts

@@ -0,0 +1,17 @@
+import type { LiteralBaseNode, ResourceLocationBaseNode, StringBaseNode, SymbolBaseNode } from '../../node';
+import type { MetaRegistry } from '../../service';
+import type { Colorizer } from './Colorizer';
+/**
+ * Use the shallowest children that have their own colorizers to provide the color tokens.
+ */
+export declare const fallback: Colorizer;
+export declare const boolean: Colorizer;
+export declare const comment: Colorizer;
+export declare const error: Colorizer;
+export declare const literal: Colorizer<LiteralBaseNode>;
+export declare const number: Colorizer;
+export declare const resourceLocation: Colorizer<ResourceLocationBaseNode>;
+export declare const string: Colorizer<StringBaseNode>;
+export declare const symbol: Colorizer<SymbolBaseNode>;
+export declare function registerColorizers(meta: MetaRegistry): void;
+//# sourceMappingURL=builtin.d.ts.map

package/lib/processor/colorizer/builtin.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerColorizers = exports.symbol = exports.string = exports.resourceLocation = exports.number = exports.literal = exports.error = exports.comment = exports.boolean = exports.fallback = void 0;
+const source_1 = require("../../source");
+const util_1 = require("../util");
+const Colorizer_1 = require("./Colorizer");
+/**
+ * Use the shallowest children that have their own colorizers to provide the color tokens.
+ */
+const fallback = (node, ctx) => {
+    const ans = [];
+    (0, util_1.traversePreOrder)(node, node => !ctx.meta.hasColorizer(node.type) && (!ctx.range || source_1.Range.intersects(node.range, ctx.range)), node => ctx.meta.hasColorizer(node.type), node => {
+        const colorizer = ctx.meta.getColorizer(node.type);
+        const result = colorizer(node, ctx);
+        ans.push(...result);
+    });
+    return Object.freeze(ans);
+};
+exports.fallback = fallback;
+const boolean = node => {
+    return [Colorizer_1.ColorToken.create(node, 'literal')];
+};
+exports.boolean = boolean;
+const comment = node => {
+    return [Colorizer_1.ColorToken.create(node, 'comment')];
+};
+exports.comment = comment;
+const error = node => {
+    return [Colorizer_1.ColorToken.create(node, 'error')];
+};
+exports.error = error;
+const literal = node => {
+    return [Colorizer_1.ColorToken.create(node, node.options.colorTokenType ?? 'literal')];
+};
+exports.literal = literal;
+const number = node => {
+    return [Colorizer_1.ColorToken.create(node, 'number')];
+};
+exports.number = number;
+const resourceLocation = (node, _ctx) => {
+    let type;
+    switch (node.options.category) {
+        case 'function':
+        case 'tag/function':
+            type = 'function';
+            break;
+        default:
+            type = 'resourceLocation';
+            break;
+    }
+    return [Colorizer_1.ColorToken.create(node, type)];
+};
+exports.resourceLocation = resourceLocation;
+const string = (node, ctx) => {
+    if (node.children) {
+        const colorizer = ctx.meta.getColorizer(node.children[0].type);
+        const result = colorizer(node.children[0], ctx);
+        // TODO: Fill the gap between the last token and the ending quote with errors.
+        return Colorizer_1.ColorToken.fillGap(result, node.range, node.options.colorTokenType ?? 'string');
+    }
+    else {
+        return [Colorizer_1.ColorToken.create(node, node.options.colorTokenType ?? 'string')];
+    }
+};
+exports.string = string;
+const symbol = node => {
+    // TODO: Set the modifiers according to `node.symbol`.
+    return [Colorizer_1.ColorToken.create(node, 'variable')];
+};
+exports.symbol = symbol;
+function registerColorizers(meta) {
+    meta.registerColorizer('boolean', exports.boolean);
+    meta.registerColorizer('comment', exports.comment);
+    meta.registerColorizer('error', exports.error);
+    meta.registerColorizer('float', exports.number);
+    meta.registerColorizer('integer', exports.number);
+    meta.registerColorizer('long', exports.number);
+    meta.registerColorizer('literal', exports.literal);
+    meta.registerColorizer('resource_location', exports.resourceLocation);
+    meta.registerColorizer('string', exports.string);
+    meta.registerColorizer('symbol', exports.symbol);
+}
+exports.registerColorizers = registerColorizers;
+//# sourceMappingURL=builtin.js.map

package/lib/processor/colorizer/index.d.ts

@@ -0,0 +1,3 @@
+export * as colorizer from './builtin';
+export * from './Colorizer';
+//# sourceMappingURL=index.d.ts.map

package/lib/processor/colorizer/index.js

@@ -0,0 +1,28 @@
+"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;
+};
+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.colorizer = void 0;
+exports.colorizer = __importStar(require("./builtin"));
+__exportStar(require("./Colorizer"), exports);
+//# sourceMappingURL=index.js.map

package/lib/processor/completer/Completer.d.ts

@@ -0,0 +1,75 @@
+import type { AstNode } from '../../node';
+import type { CompleterContext } from '../../service';
+import type { RangeLike } from '../../source';
+import { Range } from '../../source';
+export declare type Completer<N = AstNode> = (node: N, ctx: CompleterContext) => CompletionItem[];
+export declare const enum CompletionKind {
+    Text = 1,
+    Method = 2,
+    Function = 3,
+    Constructor = 4,
+    Field = 5,
+    Variable = 6,
+    Class = 7,
+    Interface = 8,
+    Module = 9,
+    Property = 10,
+    Unit = 11,
+    Value = 12,
+    Enum = 13,
+    Keyword = 14,
+    Snippet = 15,
+    Color = 16,
+    File = 17,
+    Reference = 18,
+    Folder = 19,
+    EnumMember = 20,
+    Constant = 21,
+    Struct = 22,
+    Event = 23,
+    Operator = 24,
+    TypeParameter = 25
+}
+export interface CompletionItem {
+    label: string;
+    range: Range;
+    kind?: CompletionKind;
+    detail?: string;
+    documentation?: string;
+    deprecated?: boolean;
+    /**
+     * `$`, `\`, and `}` needs to be escaped if they are not used for TextMate snippet purposes.
+     */
+    insertText?: string;
+    sortText?: string;
+    filterText?: string;
+}
+export declare namespace CompletionItem {
+    /**
+     * If no `insertText` is provided in `other`, the value of `label` will be escaped for TextMate purposes
+     * (@see {@link escape}) and used as the insert text.
+     *
+     * @example
+     * create('foo', range) // insertText = 'foo'
+     * create('\\ $ }', range) // insertText = '\\\\ \\$ \\}'
+     * create('foo', range, { insertText: '\\ $ }' }) // insertText = '\\ $ }'
+     */
+    function create(label: string, range: RangeLike, other?: Partial<CompletionItem>): CompletionItem;
+    /**
+     * Returns if `textToInsert` contains any characters that need to be escaped for TextMate (`$`, `\`, or `}`)
+     */
+    function needsEscape(textToInsert: string): boolean;
+    /**
+     * Escape `$`, `\`, and `}` in `textToInsert`
+     */
+    function escape(textToInsert: string): string;
+}
+export declare class InsertTextBuilder {
+    #private;
+    literal(str: string): this;
+    placeholder(...defaultValues: string[]): this;
+    exitPlace(): this;
+    build(): string;
+    if(condition: boolean, callback: (b: this) => unknown): this;
+}
+//# sourceMappingURL=Completer.d.ts.map

package/lib/processor/completer/Completer.js

@@ -0,0 +1,92 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _InsertTextBuilder_ans, _InsertTextBuilder_nextPlaceholder;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertTextBuilder = exports.CompletionItem = void 0;
+const source_1 = require("../../source");
+var CompletionItem;
+(function (CompletionItem) {
+    /* istanbul ignore next */
+    /**
+     * If no `insertText` is provided in `other`, the value of `label` will be escaped for TextMate purposes
+     * (@see {@link escape}) and used as the insert text.
+     *
+     * @example
+     * create('foo', range) // insertText = 'foo'
+     * create('\\ $ }', range) // insertText = '\\\\ \\$ \\}'
+     * create('foo', range, { insertText: '\\ $ }' }) // insertText = '\\ $ }'
+     */
+    function create(label, range, other) {
+        const shouldEscape = other?.insertText === undefined && needsEscape(label);
+        return {
+            ...other,
+            label,
+            range: source_1.Range.get(range),
+            ...shouldEscape ? { insertText: escape(label) } : {},
+        };
+    }
+    CompletionItem.create = create;
+    /**
+     * Returns if `textToInsert` contains any characters that need to be escaped for TextMate (`$`, `\`, or `}`)
+     */
+    function needsEscape(textToInsert) {
+        return /[\\$}]/.test(textToInsert);
+    }
+    CompletionItem.needsEscape = needsEscape;
+    /**
+     * Escape `$`, `\`, and `}` in `textToInsert`
+     */
+    function escape(textToInsert) {
+        return textToInsert.replace(/([\\$}])/g, '\\$1');
+    }
+    CompletionItem.escape = escape;
+})(CompletionItem = exports.CompletionItem || (exports.CompletionItem = {}));
+class InsertTextBuilder {
+    constructor() {
+        _InsertTextBuilder_ans.set(this, '');
+        _InsertTextBuilder_nextPlaceholder.set(this, 1);
+    }
+    literal(str) {
+        __classPrivateFieldSet(this, _InsertTextBuilder_ans, __classPrivateFieldGet(this, _InsertTextBuilder_ans, "f") + CompletionItem.escape(str), "f");
+        return this;
+    }
+    placeholder(...defaultValues) {
+        if (defaultValues.length === 0) {
+            __classPrivateFieldSet(this, _InsertTextBuilder_ans, __classPrivateFieldGet(this, _InsertTextBuilder_ans, "f") + `$\{${__classPrivateFieldGet(this, _InsertTextBuilder_nextPlaceholder, "f")}}`, "f");
+        }
+        else if (defaultValues.length === 1) {
+            __classPrivateFieldSet(this, _InsertTextBuilder_ans, __classPrivateFieldGet(this, _InsertTextBuilder_ans, "f") + `$\{${__classPrivateFieldGet(this, _InsertTextBuilder_nextPlaceholder, "f")}:${CompletionItem.escape(defaultValues[0])}}`, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _InsertTextBuilder_ans, __classPrivateFieldGet(this, _InsertTextBuilder_ans, "f") + `$\{${__classPrivateFieldGet(this, _InsertTextBuilder_nextPlaceholder, "f")}|${defaultValues.map(v => v.replace(/([\\$},|])/g, '\\$1')).join(',')}|}`, "f");
+        }
+        __classPrivateFieldSet(this, _InsertTextBuilder_nextPlaceholder, __classPrivateFieldGet(this, _InsertTextBuilder_nextPlaceholder, "f") + 1, "f");
+        return this;
+    }
+    exitPlace() {
+        __classPrivateFieldSet(this, _InsertTextBuilder_ans, __classPrivateFieldGet(this, _InsertTextBuilder_ans, "f") + '$0', "f");
+        return this;
+    }
+    build() {
+        return __classPrivateFieldGet(this, _InsertTextBuilder_ans, "f");
+    }
+    if(condition, callback) {
+        if (condition) {
+            callback(this);
+        }
+        return this;
+    }
+}
+exports.InsertTextBuilder = InsertTextBuilder;
+_InsertTextBuilder_ans = new WeakMap(), _InsertTextBuilder_nextPlaceholder = new WeakMap();
+//# sourceMappingURL=Completer.js.map

package/lib/processor/completer/builtin.d.ts

@@ -0,0 +1,30 @@
+import type { FileNode, LiteralBaseNode, PairNode, RecordBaseNode, ResourceLocationNode, StringBaseNode, SymbolBaseNode } from '../../node';
+import { AstNode } from '../../node';
+import type { BooleanBaseNode } from '../../node/BooleanNode';
+import type { CompleterContext, MetaRegistry } from '../../service';
+import type { RangeLike } from '../../source';
+import type { Completer } from './Completer';
+import { CompletionItem } from './Completer';
+/**
+ * Uses the shallowest selected node that has its own completer to provide the completion items.
+ */
+export declare const dispatch: Completer<AstNode>;
+export declare const fallback: Completer<AstNode>;
+export declare const boolean: Completer<BooleanBaseNode>;
+/**
+ * Dispatches to the corresponding file for the language.
+ */
+export declare const file: Completer<FileNode<AstNode>>;
+export declare const literal: Completer<LiteralBaseNode>;
+export declare const noop: Completer<any>;
+interface RecordOptions<K extends AstNode, V extends AstNode, N extends RecordBaseNode<K, V>> {
+    key: (record: N, pair: PairNode<K, V> | undefined, ctx: CompleterContext, range: RangeLike, insertValue: boolean, insertPairEnd: boolean, existingKeys: K[]) => CompletionItem[];
+    value: (record: N, pair: PairNode<K, V>, ctx: CompleterContext) => CompletionItem[];
+}
+export declare function record<K extends AstNode, V extends AstNode, N extends RecordBaseNode<K, V>>(o: RecordOptions<K, V, N>): Completer<N>;
+export declare const resourceLocation: Completer<ResourceLocationNode>;
+export declare const string: Completer<StringBaseNode>;
+export declare const symbol: Completer<SymbolBaseNode>;
+export declare function registerCompleters(meta: MetaRegistry): void;
+export {};
+//# sourceMappingURL=builtin.d.ts.map

package/lib/processor/completer/builtin.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCompleters = exports.symbol = exports.string = exports.resourceLocation = exports.record = exports.noop = exports.literal = exports.file = exports.boolean = exports.fallback = exports.dispatch = void 0;
+const binary_search_1 = __importDefault(require("binary-search"));
+const common_1 = require("../../common");
+const node_1 = require("../../node");
+const service_1 = require("../../service");
+const source_1 = require("../../source");
+const Completer_1 = require("./Completer");
+/**
+ * Uses the shallowest selected node that has its own completer to provide the completion items.
+ */
+const dispatch = (node, ctx) => {
+    const child = node_1.AstNode.findShallowestChild({
+        node,
+        needle: ctx.offset,
+        endInclusive: true,
+        predicate: n => ctx.meta.hasCompleter(n.type),
+    });
+    return child
+        ? ctx.meta.getCompleter(child.type)(child, ctx)
+        : [];
+};
+exports.dispatch = dispatch;
+exports.fallback = exports.dispatch;
+const boolean = (node, ctx) => {
+    return [
+        Completer_1.CompletionItem.create('false', node, { kind: 21 /* Constant */ }),
+        Completer_1.CompletionItem.create('true', node, { kind: 21 /* Constant */ }),
+    ];
+};
+exports.boolean = boolean;
+/**
+ * Dispatches to the corresponding file for the language.
+ */
+const file = (node, ctx) => {
+    const completer = ctx.meta.getCompleterForLanguageID(ctx.doc.languageId);
+    return completer(node.children[0], ctx);
+};
+exports.file = file;
+const literal = node => {
+    const kind = new Map([
+        ['enum', 13 /* Enum */],
+        ['enumMember', 20 /* EnumMember */],
+        ['function', 3 /* Function */],
+        ['keyword', 14 /* Keyword */],
+        ['literal', 14 /* Keyword */],
+        ['number', 21 /* Constant */],
+        ['operator', 24 /* Operator */],
+        ['property', 10 /* Property */],
+        ['resourceLocation', 17 /* File */],
+        ['variable', 6 /* Variable */],
+    ]).get(node.options.colorTokenType ?? 'keyword') ?? 14 /* Keyword */;
+    return node.options.pool.map(v => Completer_1.CompletionItem.create(v, node, { kind })) ?? [];
+};
+exports.literal = literal;
+const noop = () => [];
+exports.noop = noop;
+function record(o) {
+    return (node, ctx) => {
+        if (!source_1.Range.contains(source_1.Range.translate(node, 1, -1), ctx.offset, true)) {
+            return [];
+        }
+        const completeKeys = (pair) => o.key(node, pair, ctx, pair?.key ?? ctx.offset, false, false, existingKeys);
+        const completePairs = (pair) => o.key(node, pair, ctx, pair ?? ctx.offset, true, hasNextPair || !!pair?.end, existingKeys);
+        const existingKeys = node.children
+            .filter((n) => !!n.key)
+            .map(n => n.key);
+        const index = (0, binary_search_1.default)(node.children, ctx.offset, (n, o) => n.end
+            ? source_1.Range.compareOffset(source_1.Range.translate(n, 0, -1), o, true)
+            : source_1.Range.compareOffset(n.range, o, true));
+        const pair = index >= 0 ? node.children[index] : undefined;
+        const hasNextPair = !!node.children.find(n => n.range.start > ctx.offset);
+        if (!pair) {
+            return completePairs(undefined);
+        }
+        const { key, sep, value } = pair;
+        if (!key && !sep && !value) {
+            return completePairs(undefined);
+        }
+        if ((key && source_1.Range.contains(key, ctx.offset, true)) || (sep && ctx.offset <= sep.start) || (value && ctx.offset < value.range.start)) {
+            // Selected key.
+            if (!value || source_1.Range.isEmpty(value.range)) {
+                return completePairs(pair);
+            }
+            return completeKeys(pair);
+        }
+        if ((value && source_1.Range.contains(value, ctx.offset, true)) || (sep && ctx.offset >= sep.end) || (key && ctx.offset > key.range.end)) {
+            // Selected value.
+            return o.value(node, pair, ctx);
+        }
+        return [];
+    };
+}
+exports.record = record;
+const resourceLocation = (node, ctx) => {
+    const config = service_1.LinterConfigValue.destruct(ctx.config.lint.idOmitDefaultNamespace);
+    const includeEmptyNamespace = !node.options.isPredicate && node.namespace === '';
+    const includeDefaultNamespace = node.options.isPredicate || config?.ruleValue !== true;
+    const excludeDefaultNamespace = !node.options.isPredicate && config?.ruleValue !== false;
+    const getPool = (category) => optimizePool(Object.keys(ctx.symbols.getVisibleSymbols(category, ctx.doc.uri)));
+    const optimizePool = (pool) => {
+        const defaultNsPrefix = `${common_1.ResourceLocation.DefaultNamespace}${common_1.ResourceLocation.NamespacePathSep}`;
+        const defaultNsIds = [];
+        const otherIds = [];
+        for (const id of pool) {
+            if (id.startsWith(defaultNsPrefix)) {
+                defaultNsIds.push(id);
+            }
+            else {
+                otherIds.push(id);
+            }
+        }
+        const ans = [
+            ...otherIds,
+            ...includeDefaultNamespace ? defaultNsIds : [],
+            ...excludeDefaultNamespace ? defaultNsIds.map(id => id.slice(defaultNsPrefix.length)) : [],
+            ...includeEmptyNamespace ? defaultNsIds.map(id => id.slice(common_1.ResourceLocation.DefaultNamespace.length)) : [],
+        ];
+        if (node.options.namespacePathSep === '.') {
+            return ans.map(v => v.replace(common_1.ResourceLocation.NamespacePathSep, '.'));
+        }
+        return ans;
+    };
+    const pool = node.options.pool
+        ? optimizePool(node.options.pool)
+        : [
+            ...getPool(node.options.category),
+            ...node.options.allowTag
+                ? getPool(`tag/${node.options.category}`)
+                    .map(v => `${common_1.ResourceLocation.TagPrefix}${v}`)
+                : [],
+        ];
+    return pool.map(v => Completer_1.CompletionItem.create(v, node, { kind: 3 /* Function */ }));
+};
+exports.resourceLocation = resourceLocation;
+const string = (node, ctx) => {
+    if (node.children?.length) {
+        // FIXME: Escape quotes/slashes in the result. Note that `\`, `$`, and `}` have to be escaped due to TextMate syntax.
+        return (0, exports.dispatch)(node.children[0], ctx);
+    }
+    if (node.options.quotes && node.value === '') {
+        return node.options.quotes.map(q => Completer_1.CompletionItem.create(`${q}${q}`, node, {
+            insertText: `${q}$1${q}`,
+            kind: 12 /* Value */,
+        }));
+    }
+    return [];
+};
+exports.string = string;
+const symbol = (node, ctx) => {
+    return Object
+        .keys(ctx.symbols.query(ctx.doc, node.options.category, ...node.options.parentPath ?? []).visibleMembers)
+        .map(v => Completer_1.CompletionItem.create(v, node, { kind: 6 /* Variable */ }));
+};
+exports.symbol = symbol;
+function registerCompleters(meta) {
+    meta.registerCompleter('boolean', exports.boolean);
+    meta.registerCompleter('comment', exports.noop);
+    meta.registerCompleter('float', exports.noop);
+    meta.registerCompleter('integer', exports.noop);
+    meta.registerCompleter('long', exports.noop);
+    meta.registerCompleter('literal', exports.literal);
+    meta.registerCompleter('resource_location', exports.resourceLocation);
+    meta.registerCompleter('string', exports.string);
+    meta.registerCompleter('symbol', exports.symbol);
+}
+exports.registerCompleters = registerCompleters;
+//# sourceMappingURL=builtin.js.map

package/lib/processor/completer/index.d.ts

@@ -0,0 +1,3 @@
+export * as completer from './builtin';
+export * from './Completer';
+//# sourceMappingURL=index.d.ts.map

package/lib/processor/completer/index.js

@@ -0,0 +1,28 @@
+"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;
+};
+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.completer = void 0;
+exports.completer = __importStar(require("./builtin"));
+__exportStar(require("./Completer"), exports);
+//# sourceMappingURL=index.js.map

package/lib/processor/formatter/Formatter.d.ts

@@ -0,0 +1,6 @@
+import type { AstNode } from '../../node';
+import type { FormatterContext } from '../../service';
+export declare type Formatter<N = AstNode> = (node: N, ctx: FormatterContext) => string;
+export declare function formatterContextIndentation(ctx: FormatterContext, additionalLevels?: number): string;
+export declare function indentFormatter(ctx: FormatterContext, additionalLevels?: number): FormatterContext;
+//# sourceMappingURL=Formatter.d.ts.map

package/lib/processor/formatter/Formatter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indentFormatter = exports.formatterContextIndentation = void 0;
+function formatterContextIndentation(ctx, additionalLevels = 0) {
+    const total = ctx.indentLevel + additionalLevels;
+    return ctx.insertSpaces ? ' '.repeat(total * ctx.tabSize) : '\t'.repeat(total);
+}
+exports.formatterContextIndentation = formatterContextIndentation;
+function indentFormatter(ctx, additionalLevels = 1) {
+    return {
+        ...ctx,
+        indentLevel: ctx.indentLevel + additionalLevels,
+        indent(additionalLevels) {
+            return formatterContextIndentation(this, additionalLevels);
+        },
+    };
+}
+exports.indentFormatter = indentFormatter;
+//# sourceMappingURL=Formatter.js.map

package/lib/processor/formatter/builtin.d.ts

@@ -0,0 +1,15 @@
+import type { AstNode, BooleanBaseNode, CommentNode, FileNode, FloatBaseNode, IntegerNode, LiteralBaseNode, LongNode, ResourceLocationBaseNode, StringBaseNode } from '../../node';
+import type { MetaRegistry } from '../../service';
+import type { Formatter } from './Formatter';
+export declare const fallback: Formatter;
+export declare const file: Formatter<FileNode<AstNode>>;
+export declare const boolean: Formatter<BooleanBaseNode>;
+export declare const comment: Formatter<CommentNode>;
+export declare const float: Formatter<FloatBaseNode>;
+export declare const integer: Formatter<IntegerNode>;
+export declare const literal: Formatter<LiteralBaseNode>;
+export declare const long: Formatter<LongNode>;
+export declare const resourceLocation: Formatter<ResourceLocationBaseNode>;
+export declare const string: Formatter<StringBaseNode>;
+export declare function registerFormatters(meta: MetaRegistry): void;
+//# sourceMappingURL=builtin.d.ts.map