@spyglassmc/core 0.1.0

package/lib/node/BooleanNode.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanNode = void 0;
+const source_1 = require("../source");
+var BooleanNode;
+(function (BooleanNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'boolean';
+    }
+    BooleanNode.is = is;
+    function mock(range) {
+        return {
+            type: 'boolean',
+            range: source_1.Range.get(range),
+        };
+    }
+    BooleanNode.mock = mock;
+})(BooleanNode = exports.BooleanNode || (exports.BooleanNode = {}));
+//# sourceMappingURL=BooleanNode.js.map

package/lib/node/CommentNode.d.ts

@@ -0,0 +1,12 @@
+import type { AstNode } from './AstNode';
+export interface CommentNode extends AstNode {
+    readonly type: 'comment';
+    /**
+     * The actual comment with prefixes and suffixes removed.
+     */
+    readonly comment: string;
+}
+export declare namespace CommentNode {
+    function is(obj: AstNode | undefined): obj is CommentNode;
+}
+//# sourceMappingURL=CommentNode.d.ts.map

package/lib/node/CommentNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentNode = void 0;
+var CommentNode;
+(function (CommentNode) {
+    function is(obj) {
+        return obj?.type === 'comment';
+    }
+    CommentNode.is = is;
+})(CommentNode = exports.CommentNode || (exports.CommentNode = {}));
+//# sourceMappingURL=CommentNode.js.map

package/lib/node/ErrorNode.d.ts

@@ -0,0 +1,8 @@
+import type { AstNode } from './AstNode';
+export interface ErrorNode extends AstNode {
+    readonly type: 'error';
+}
+export declare namespace ErrorNode {
+    function is(obj: AstNode): obj is ErrorNode;
+}
+//# sourceMappingURL=ErrorNode.d.ts.map

package/lib/node/ErrorNode.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorNode = void 0;
+var ErrorNode;
+(function (ErrorNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'error';
+    }
+    ErrorNode.is = is;
+})(ErrorNode = exports.ErrorNode || (exports.ErrorNode = {}));
+//# sourceMappingURL=ErrorNode.js.map

package/lib/node/FileNode.d.ts

@@ -0,0 +1,21 @@
+import type { AstNode } from '../node';
+import type { LanguageError } from '../source';
+import type { SymbolTable } from '../symbol';
+export interface FileNode<CN extends AstNode> extends AstNode {
+    readonly type: 'file';
+    readonly children: CN[];
+    locals: SymbolTable;
+    readonly parserErrors: readonly LanguageError[];
+    /**
+     * Only exists when the file has been checked.
+     */
+    checkerErrors?: readonly LanguageError[];
+    /**
+     * Only exists when the file has been checked.
+     */
+    linterErrors?: readonly LanguageError[];
+}
+export declare namespace FileNode {
+    function getErrors(node: FileNode<any>): LanguageError[];
+}
+//# sourceMappingURL=FileNode.d.ts.map

package/lib/node/FileNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileNode = void 0;
+var FileNode;
+(function (FileNode) {
+    function getErrors(node) {
+        return [...node.parserErrors, ...node.checkerErrors ?? [], ...node.linterErrors ?? []];
+    }
+    FileNode.getErrors = getErrors;
+})(FileNode = exports.FileNode || (exports.FileNode = {}));
+//# sourceMappingURL=FileNode.js.map

package/lib/node/FloatNode.d.ts

@@ -0,0 +1,13 @@
+import type { RangeLike } from '../source';
+import type { AstNode } from './AstNode';
+export interface FloatBaseNode extends AstNode {
+    readonly value: number;
+}
+export interface FloatNode extends FloatBaseNode {
+    readonly type: 'float';
+}
+export declare namespace FloatNode {
+    function is(obj: object): obj is FloatNode;
+    function mock(range: RangeLike): FloatNode;
+}
+//# sourceMappingURL=FloatNode.d.ts.map

package/lib/node/FloatNode.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatNode = void 0;
+const source_1 = require("../source");
+var FloatNode;
+(function (FloatNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'float';
+    }
+    FloatNode.is = is;
+    function mock(range) {
+        return {
+            type: 'float',
+            range: source_1.Range.get(range),
+            value: 0,
+        };
+    }
+    FloatNode.mock = mock;
+})(FloatNode = exports.FloatNode || (exports.FloatNode = {}));
+//# sourceMappingURL=FloatNode.js.map

package/lib/node/IntegerNode.d.ts

@@ -0,0 +1,13 @@
+import type { RangeLike } from '../source';
+import type { AstNode } from './AstNode';
+export interface IntegerBaseNode extends AstNode {
+    readonly value: number;
+}
+export interface IntegerNode extends IntegerBaseNode {
+    readonly type: 'integer';
+}
+export declare namespace IntegerNode {
+    function is(obj: object): obj is IntegerNode;
+    function mock(range: RangeLike): IntegerNode;
+}
+//# sourceMappingURL=IntegerNode.d.ts.map

package/lib/node/IntegerNode.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerNode = void 0;
+const source_1 = require("../source");
+var IntegerNode;
+(function (IntegerNode) {
+    function is(obj) {
+        return obj.type === 'integer';
+    }
+    IntegerNode.is = is;
+    function mock(range) {
+        return {
+            type: 'integer',
+            range: source_1.Range.get(range),
+            value: 0,
+        };
+    }
+    IntegerNode.mock = mock;
+})(IntegerNode = exports.IntegerNode || (exports.IntegerNode = {}));
+//# sourceMappingURL=IntegerNode.js.map

package/lib/node/ListNode.d.ts

@@ -0,0 +1,15 @@
+import type { Range } from '../source';
+import type { AstNode } from './AstNode';
+export interface ListNode<V extends AstNode> extends AstNode {
+    readonly children: ItemNode<V>[];
+}
+export interface ItemNode<V extends AstNode> extends AstNode {
+    readonly type: 'item';
+    readonly children?: [V];
+    readonly value?: V;
+    readonly sep?: Range;
+}
+export declare namespace ItemNode {
+    function is<V extends AstNode>(node: AstNode | undefined): node is ItemNode<V>;
+}
+//# sourceMappingURL=ListNode.d.ts.map

package/lib/node/ListNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemNode = void 0;
+var ItemNode;
+(function (ItemNode) {
+    function is(node) {
+        return node?.type === 'item';
+    }
+    ItemNode.is = is;
+})(ItemNode = exports.ItemNode || (exports.ItemNode = {}));
+//# sourceMappingURL=ListNode.js.map

package/lib/node/LiteralNode.d.ts

@@ -0,0 +1,19 @@
+import type { ColorTokenType } from '../processor';
+import type { RangeLike } from '../source';
+import type { AstNode } from './AstNode';
+export interface LiteralOptions {
+    pool: string[];
+    colorTokenType?: ColorTokenType;
+}
+export interface LiteralBaseNode extends AstNode {
+    readonly options: LiteralOptions;
+    readonly value: string;
+}
+export interface LiteralNode extends LiteralBaseNode {
+    readonly type: 'literal';
+}
+export declare namespace LiteralNode {
+    function is(obj: object): obj is LiteralNode;
+    function mock(range: RangeLike, options: LiteralOptions): LiteralNode;
+}
+//# sourceMappingURL=LiteralNode.d.ts.map

package/lib/node/LiteralNode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralNode = void 0;
+const source_1 = require("../source");
+var LiteralNode;
+(function (LiteralNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'literal';
+    }
+    LiteralNode.is = is;
+    function mock(range, options) {
+        return {
+            type: 'literal',
+            range: source_1.Range.get(range),
+            options,
+            value: '',
+        };
+    }
+    LiteralNode.mock = mock;
+})(LiteralNode = exports.LiteralNode || (exports.LiteralNode = {}));
+//# sourceMappingURL=LiteralNode.js.map

package/lib/node/LongNode.d.ts

@@ -0,0 +1,13 @@
+import type { RangeLike } from '../source';
+import type { AstNode } from './AstNode';
+export interface LongBaseNode extends AstNode {
+    readonly value: bigint;
+}
+export interface LongNode extends LongBaseNode {
+    readonly type: 'long';
+}
+export declare namespace LongNode {
+    function is(obj: object): obj is LongNode;
+    function mock(range: RangeLike): LongNode;
+}
+//# sourceMappingURL=LongNode.d.ts.map

package/lib/node/LongNode.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LongNode = void 0;
+const source_1 = require("../source");
+var LongNode;
+(function (LongNode) {
+    function is(obj) {
+        return obj.type === 'long';
+    }
+    LongNode.is = is;
+    function mock(range) {
+        return {
+            type: 'long',
+            range: source_1.Range.get(range),
+            value: 0n,
+        };
+    }
+    LongNode.mock = mock;
+})(LongNode = exports.LongNode || (exports.LongNode = {}));
+//# sourceMappingURL=LongNode.js.map

package/lib/node/RecordNode.d.ts

@@ -0,0 +1,20 @@
+import type { Range } from '../source';
+import type { AstNode } from './AstNode';
+export interface RecordBaseNode<K extends AstNode, V extends AstNode> extends AstNode {
+    readonly children: PairNode<K, V>[];
+}
+export interface RecordNode<K extends AstNode, V extends AstNode> extends RecordBaseNode<K, V> {
+    type: 'record';
+}
+export interface PairNode<K extends AstNode, V extends AstNode> extends AstNode {
+    readonly type: 'pair';
+    readonly children?: [K, V] | [K] | [V];
+    readonly key?: K;
+    readonly sep?: Range;
+    readonly value?: V;
+    readonly end?: Range;
+}
+export declare namespace PairNode {
+    function is<K extends AstNode, V extends AstNode>(node: AstNode | undefined): node is PairNode<K, V>;
+}
+//# sourceMappingURL=RecordNode.d.ts.map

package/lib/node/RecordNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairNode = void 0;
+var PairNode;
+(function (PairNode) {
+    function is(node) {
+        return node?.type === 'pair';
+    }
+    PairNode.is = is;
+})(PairNode = exports.PairNode || (exports.PairNode = {}));
+//# sourceMappingURL=RecordNode.js.map

package/lib/node/ResourceLocationNode.d.ts

@@ -0,0 +1,41 @@
+import type { FullResourceLocation } from '../common';
+import type { RangeLike } from '../source';
+import type { ResourceLocationCategory, SymbolAccessType, SymbolUsageType, TaggableResourceLocationCategory } from '../symbol';
+import type { AstNode } from './AstNode';
+export declare type ResourceLocationOptions = {
+    accessType?: SymbolAccessType;
+    isPredicate?: boolean;
+    usageType?: SymbolUsageType;
+    namespacePathSep?: ':' | '.';
+} & ({
+    category: ResourceLocationCategory;
+    pool?: undefined;
+    allowTag?: false;
+    allowUnknown?: false;
+} | {
+    category: TaggableResourceLocationCategory;
+    pool?: undefined;
+    allowTag?: boolean;
+    allowUnknown?: false;
+} | {
+    category?: undefined;
+    pool: string[];
+    allowTag?: false;
+    allowUnknown?: boolean;
+});
+export interface ResourceLocationBaseNode extends AstNode {
+    readonly options: ResourceLocationOptions;
+    readonly isTag?: boolean;
+    readonly namespace?: string;
+    readonly path?: string[];
+}
+export interface ResourceLocationNode extends ResourceLocationBaseNode {
+    readonly type: 'resource_location';
+}
+export declare namespace ResourceLocationNode {
+    function is(obj: AstNode | undefined): obj is ResourceLocationNode;
+    function mock(range: RangeLike, options: ResourceLocationOptions): ResourceLocationNode;
+    function toString(node: ResourceLocationBaseNode, type?: 'full'): FullResourceLocation;
+    function toString(node: ResourceLocationBaseNode, type?: 'origin' | 'full' | 'short'): string;
+}
+//# sourceMappingURL=ResourceLocationNode.d.ts.map

package/lib/node/ResourceLocationNode.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceLocationNode = void 0;
+const common_1 = require("../common");
+const source_1 = require("../source");
+var ResourceLocationNode;
+(function (ResourceLocationNode) {
+    /**
+     * The prefix for tags.
+     */
+    const TagPrefix = common_1.ResourceLocation.TagPrefix;
+    /**
+     * The seperator of namespace and path.
+     */
+    const NamespacePathSep = common_1.ResourceLocation.NamespacePathSep;
+    /**
+     * The seperator between different path segments.
+     */
+    const PathSep = common_1.ResourceLocation.PathSep;
+    const DefaultNamespace = common_1.ResourceLocation.DefaultNamespace;
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj?.type === 'resource_location';
+    }
+    ResourceLocationNode.is = is;
+    function mock(range, options) {
+        return {
+            type: 'resource_location',
+            range: source_1.Range.get(range),
+            options,
+        };
+    }
+    ResourceLocationNode.mock = mock;
+    function toString(node, type = 'origin') {
+        const path = node.path ? node.path.join(PathSep) : '';
+        let id;
+        /*
+         * `node.namespace` has four statuses here:
+         * - `minecraft`
+         * - `` (yes, empty string)
+         * - undefined
+         * - any other namespaces.
+         *
+         * Whether `node.namespace !== undefined` or simply `node.namespace` is used in the condition is carefully selected.
+         */
+        switch (type) {
+            case 'origin':
+                // Use `node.namespace !== undefined`, so that empty namespaces can be correctly restored to string.
+                id = node.namespace !== undefined ? `${node.namespace}${NamespacePathSep}${path}` : path;
+                break;
+            case 'full':
+                // Use `node.namespace` before `||`, so that both undefined and empty value can result in the default namespace.
+                // Use `||` instead of `??`, so that empty namespaces can be converted to the default namespace.
+                id = `${node.namespace || DefaultNamespace}${NamespacePathSep}${path}`;
+                break;
+            case 'short':
+                // Use `node.namespace` before `&&` for the same reason stated above.
+                id = node.namespace && node.namespace !== DefaultNamespace ? `${node.namespace}${NamespacePathSep}${path}` : path;
+                break;
+        }
+        return node.isTag ? `${TagPrefix}${id}` : id;
+    }
+    ResourceLocationNode.toString = toString;
+})(ResourceLocationNode = exports.ResourceLocationNode || (exports.ResourceLocationNode = {}));
+//# sourceMappingURL=ResourceLocationNode.js.map

package/lib/node/Sequence.d.ts

@@ -0,0 +1,22 @@
+import type { AstNode } from '../node';
+import type { Range } from '../source';
+export interface SequenceNode<CN extends AstNode = AstNode> extends AstNode {
+    /**
+     * An array of `AstNode`s that fully make up this node.
+     */
+    children: CN[];
+}
+/**
+ * A utility object for temporarily storing a sequence rule.
+ *
+ * @template CN Child node.
+ */
+export interface SequenceUtil<CN extends AstNode = AstNode> {
+    isSequenceUtil: true;
+    range: Range;
+    children: CN[];
+}
+export declare namespace SequenceUtil {
+    function is<CN extends AstNode>(obj: object | undefined): obj is SequenceUtil<CN>;
+}
+//# sourceMappingURL=Sequence.d.ts.map

package/lib/node/Sequence.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequenceUtil = void 0;
+var SequenceUtil;
+(function (SequenceUtil) {
+    function is(obj) {
+        return !!obj && obj.isSequenceUtil;
+    }
+    SequenceUtil.is = is;
+})(SequenceUtil = exports.SequenceUtil || (exports.SequenceUtil = {}));
+//# sourceMappingURL=Sequence.js.map

package/lib/node/StringNode.d.ts

@@ -0,0 +1,63 @@
+import type { Parser } from '../parser';
+import type { ColorTokenType } from '../processor';
+import type { IndexMap, RangeLike } from '../source';
+import type { AstNode } from './AstNode';
+export declare const EscapeChars: readonly ["\"", "'", "\\", "b", "f", "n", "r", "t"];
+export declare type EscapeChar = typeof EscapeChars[number];
+export declare namespace EscapeChar {
+    function is(expected: EscapeChar[] | undefined, c: string): c is EscapeChar;
+}
+export declare const EscapeTable: Map<"b" | "f" | "'" | "\"" | "n" | "r" | "t" | "\\", string>;
+export declare type Quote = "'" | '"';
+export interface StringOptions {
+    colorTokenType?: ColorTokenType;
+    escapable?: {
+        /**
+         * A list of characters that can be escaped. The current quote of the string and backslash (`\`)
+         * will be added to this list automatically.
+         */
+        characters?: EscapeChar[];
+        /**
+         * Whether escapes like `\u####` where #### is a hexdecimal numeral are allowed.
+         */
+        unicode?: boolean;
+        /**
+         * Whether unknown characters can be escaped, which would just result in the character itself.
+         */
+        allowUnknown?: boolean;
+    } | false;
+    /**
+     * A list of characters that can serve as a quotation mark.
+     */
+    quotes?: Quote[];
+    /**
+     * Whether this string could be an unquoted string. If yes, specify the list of allowed/disallowed characters that
+     * the string can contain. Otherwise set this to `false`.
+     */
+    unquotable?: {
+        allowEmpty?: boolean;
+        allowList?: Set<string>;
+        blockList?: Set<string>;
+    } | false;
+    /**
+     * An optional object describing the content of the string.
+     */
+    value?: {
+        parser: Parser;
+        type: AstNode['type'];
+    };
+}
+export declare type QuoteTypeConfig = 'always double' | 'always single' | 'prefer double' | 'prefer single';
+export interface StringBaseNode extends AstNode {
+    readonly options: StringOptions;
+    readonly value: string;
+    readonly valueMap: IndexMap;
+}
+export interface StringNode extends StringBaseNode {
+    readonly type: 'string';
+}
+export declare namespace StringNode {
+    function is(obj: object | undefined): obj is StringNode;
+    function mock(range: RangeLike, options: StringOptions): StringNode;
+}
+//# sourceMappingURL=StringNode.d.ts.map

package/lib/node/StringNode.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringNode = exports.EscapeTable = exports.EscapeChar = exports.EscapeChars = void 0;
+const source_1 = require("../source");
+exports.EscapeChars = ['"', "'", '\\', 'b', 'f', 'n', 'r', 't'];
+var EscapeChar;
+(function (EscapeChar) {
+    /* istanbul ignore next */
+    function is(expected, c) {
+        return expected ? expected.includes(c) : false;
+    }
+    EscapeChar.is = is;
+})(EscapeChar = exports.EscapeChar || (exports.EscapeChar = {}));
+exports.EscapeTable = new Map([
+    ['"', '"'],
+    ["'", "'"],
+    ['\\', '\\'],
+    ['b', '\b'],
+    ['f', '\f'],
+    ['n', '\n'],
+    ['r', '\r'],
+    ['t', '\t'],
+]);
+var StringNode;
+(function (StringNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj?.type === 'string';
+    }
+    StringNode.is = is;
+    function mock(range, options) {
+        range = source_1.Range.get(range);
+        return {
+            type: 'string',
+            range,
+            options,
+            value: '',
+            valueMap: [{ inner: source_1.Range.create(0), outer: source_1.Range.create(range.start) }],
+        };
+    }
+    StringNode.mock = mock;
+})(StringNode = exports.StringNode || (exports.StringNode = {}));
+//# sourceMappingURL=StringNode.js.map

package/lib/node/SymbolNode.d.ts

@@ -0,0 +1,21 @@
+import type { RangeLike } from '../source';
+import type { SymbolAccessType, SymbolUsageType } from '../symbol';
+import type { AstNode } from './AstNode';
+export interface SymbolOptions {
+    category: string;
+    parentPath?: string[];
+    accessType?: SymbolAccessType;
+    usageType?: SymbolUsageType;
+}
+export interface SymbolBaseNode extends AstNode {
+    readonly options: SymbolOptions;
+    readonly value: string;
+}
+export interface SymbolNode extends SymbolBaseNode {
+    readonly type: 'symbol';
+}
+export declare namespace SymbolNode {
+    function is(obj: object): obj is SymbolNode;
+    function mock(range: RangeLike, options: SymbolOptions): SymbolNode;
+}
+//# sourceMappingURL=SymbolNode.d.ts.map

package/lib/node/SymbolNode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolNode = void 0;
+const source_1 = require("../source");
+var SymbolNode;
+(function (SymbolNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj.type === 'symbol';
+    }
+    SymbolNode.is = is;
+    function mock(range, options) {
+        return {
+            type: 'symbol',
+            range: source_1.Range.get(range),
+            options,
+            value: '',
+        };
+    }
+    SymbolNode.mock = mock;
+})(SymbolNode = exports.SymbolNode || (exports.SymbolNode = {}));
+//# sourceMappingURL=SymbolNode.js.map

package/lib/node/TableNode.d.ts

@@ -0,0 +1,17 @@
+import type { Range } from '../source';
+import type { AstNode } from './AstNode';
+export interface TableNode<K extends AstNode, V extends AstNode> extends AstNode {
+    readonly children: PairNode<K, V>[];
+}
+export interface PairNode<K extends AstNode, V extends AstNode> extends AstNode {
+    readonly type: 'pair';
+    readonly children?: [K, V] | [K] | [V];
+    readonly key?: K;
+    readonly sep?: Range;
+    readonly value?: V;
+    readonly end?: Range;
+}
+export declare namespace PairNode {
+    function is<K extends AstNode, V extends AstNode>(node: AstNode | undefined): node is PairNode<K, V>;
+}
+//# sourceMappingURL=TableNode.d.ts.map

package/lib/node/TableNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairNode = void 0;
+var PairNode;
+(function (PairNode) {
+    function is(node) {
+        return node?.type === 'pair';
+    }
+    PairNode.is = is;
+})(PairNode = exports.PairNode || (exports.PairNode = {}));
+//# sourceMappingURL=TableNode.js.map

package/lib/node/index.d.ts

@@ -0,0 +1,16 @@
+export * from './AstNode';
+export * from './BooleanNode';
+export * from './CommentNode';
+export * from './ErrorNode';
+export * from './FileNode';
+export * from './FloatNode';
+export * from './IntegerNode';
+export * from './ListNode';
+export * from './LiteralNode';
+export * from './LongNode';
+export * from './RecordNode';
+export * from './ResourceLocationNode';
+export * from './Sequence';
+export * from './StringNode';
+export * from './SymbolNode';
+//# sourceMappingURL=index.d.ts.map