@spyglassmc/core 0.1.0

package/README.md

@@ -0,0 +1,10 @@
+# `@spyglassmc/core`
+
+![banner](https://raw.githubusercontent.com/SpyglassMC/logo/main/banner.png)
+
+[![Discord](https://img.shields.io/discord/666020457568403505?logo=discord&style=flat-square)](https://discord.gg/EbdseuS)
+[![npm](https://img.shields.io/npm/v/@spyglassmc/core.svg?logo=npm&style=flat-square)](https://npmjs.com/package/@spyglassmc/core)
+[![License](https://img.shields.io/github/license/SpyglassMC/Spyglass.svg?style=flat-square)](https://github.com/SpyglassMC/Spyglass/blob/master/LICENSE)
+[![Gitmoji](https://img.shields.io/badge/gitmoji-%20😜%20😍-FFDD67.svg?style=flat-square)](https://gitmoji.carloscuesta.me/)
+
+This package is the core of the Spyglass Project. It defines the structure of a parser or validator, and provides the `SpyglassCore` class to help manage those things.

package/lib/common/Heap.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=Heap.d.ts.map

package/lib/common/Heap.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=Heap.js.map

package/lib/common/index.d.ts

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

package/lib/common/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("./util"), exports);
+//# sourceMappingURL=index.js.map

package/lib/common/util.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="node" />
+import externalBinarySearch from 'binary-search';
+import type { URL as Uri } from 'url';
+import type { ProcessorContext, RootUriString } from '../service';
+export { URL as Uri } from 'url';
+/**
+ * @param getCacheKey A function that takes the actual arguments being passed into the decorated method, and returns anything.
+ * The result of this function will be used as the key to cache the `Promise`. By default the first element in the argument
+ * list will be used.
+ *
+ * This is a decorator for async methods. Decorated methods will return the same `Promise` for
+ * the same arguments, provided that the cached `Promise` is still pending.
+ */
+export declare function CachePromise(getCacheKey?: (args: any[]) => any): MethodDecorator;
+/**
+ * This is a decorator for async methods. Decorated methods will return the same `Promise` no matter what.
+ */
+export declare const SingletonPromise: MethodDecorator;
+/**
+ * @param getKey A function that takes the actual arguments being passed into the decorated method, and returns anything.
+ * The result of this function will be used as the key to cache the `Timeout`. By default the first element in the argument
+ * list will be used.
+ *
+ * Decorated methods will be scheduled to run after `ms` milliseconds. The timer will reset when the method is called again.
+ */
+export declare function Delay(ms: number, getKey?: (args: any[]) => any): MethodDecorator;
+export declare namespace SpyglassUri {
+    const Protocol = "spyglassmc:";
+    namespace Archive {
+        const Hostname = "archive";
+        function get(archiveUri: string): RootUriString;
+        function get(archiveUri: string, pathInArchive: string): string;
+        function is(uri: Uri): boolean;
+        /**
+         * @throws When `uri` has the wrong protocol or hostname.
+         */
+        function decode(uri: Uri): {
+            archiveUri: string;
+            pathInArchive: string;
+        };
+    }
+}
+export declare type FullResourceLocation = `${string}:${string}`;
+export interface ResourceLocation {
+    isTag: boolean;
+    namespace: string | undefined;
+    path: readonly string[];
+}
+export declare namespace ResourceLocation {
+    /**
+     * The prefix for tags.
+     */
+    const TagPrefix = "#";
+    /**
+     * The seperator of namespace and path.
+     */
+    const NamespacePathSep = ":";
+    /**
+     * The seperator between different path segments.
+     */
+    const PathSep = "/";
+    const DefaultNamespace = "minecraft";
+    function lengthen(value: string): FullResourceLocation;
+    function shorten(value: string): string;
+}
+/**
+ * @returns The string value decoded from the buffer according to UTF-8.
+ * Byte order mark is correctly removed.
+ */
+export declare function bufferToString(buffer: Buffer): string;
+export declare function stringToBase64(str: string): string;
+export declare function base64ToString(base64: string): string;
+/**
+ * @throws
+ */
+export declare function getSha1(data: string | Buffer): string;
+export declare function isErrorCode(e: unknown, code: string): boolean;
+export declare function isEnoent(e: unknown): boolean;
+export declare type Arrayable<T> = T | readonly T[];
+export declare namespace Arrayable {
+    function is<T>(value: unknown, isT: (value: unknown) => value is T): value is Arrayable<T>;
+    function toArray<T>(value: Arrayable<T>): T[];
+}
+export declare namespace TypePredicates {
+    function isString(value: unknown): value is string;
+}
+export declare function promisifyAsyncIterable<T, U>(iterable: AsyncIterable<T>, joiner: (chunks: T[]) => U): Promise<U>;
+export declare const unzip: (buffer: Buffer) => Promise<Buffer>;
+export declare const zip: (buffer: Buffer) => Promise<Buffer>;
+export declare function parseGzippedJson<T>(buffer: Buffer): Promise<T>;
+export declare function isObject(value: unknown): value is Exclude<object, Array<any>>;
+export declare function merge<T extends Record<string, any>>(a: T, b: Record<string, any>): T;
+export declare type Lazy<T> = T | Lazy.ComplexLazy<T>;
+export declare namespace Lazy {
+    const LazyDiscriminator: unique symbol;
+    export type UnresolvedLazy<T> = {
+        discriminator: typeof LazyDiscriminator;
+        getter: (this: void) => T;
+    };
+    export type ResolvedLazy<T> = {
+        discriminator: typeof LazyDiscriminator;
+        getter: (this: void) => T;
+        value: T;
+    };
+    export type ComplexLazy<T> = ResolvedLazy<T> | UnresolvedLazy<T>;
+    export function create<T>(getter: (this: void) => T): UnresolvedLazy<T>;
+    export function isComplex<T = any>(lazy: any): lazy is ComplexLazy<T>;
+    export function isUnresolved<T = any>(lazy: any): lazy is UnresolvedLazy<T>;
+    export function resolve<T>(lazy: Lazy<T>): T;
+    export {};
+}
+/**
+ * @param ids An array of block/fluid IDs, with or without the namespace.
+ * @returns A map from state names to the corresponding sets of values. The first element in the value array is the default
+ * value for that state.
+ */
+export declare function getStates(category: 'block' | 'fluid', ids: readonly string[], ctx: ProcessorContext): Record<string, string[]>;
+export declare const binarySearch: typeof externalBinarySearch;
+export declare function isIterable(value: unknown): value is Iterable<unknown>;
+//# sourceMappingURL=util.d.ts.map

package/lib/common/util.js

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIterable = exports.binarySearch = exports.getStates = exports.Lazy = exports.merge = exports.isObject = exports.parseGzippedJson = exports.zip = exports.unzip = exports.promisifyAsyncIterable = exports.TypePredicates = exports.Arrayable = exports.isEnoent = exports.isErrorCode = exports.getSha1 = exports.base64ToString = exports.stringToBase64 = exports.bufferToString = exports.ResourceLocation = exports.SpyglassUri = exports.Delay = exports.SingletonPromise = exports.CachePromise = exports.Uri = void 0;
+const binary_search_1 = __importDefault(require("binary-search"));
+const crypto_1 = __importDefault(require("crypto"));
+const rfdc_1 = __importDefault(require("rfdc"));
+const util_1 = require("util");
+const zlib_1 = __importDefault(require("zlib"));
+var url_1 = require("url");
+Object.defineProperty(exports, "Uri", { enumerable: true, get: function () { return url_1.URL; } });
+/**
+ * @param getCacheKey A function that takes the actual arguments being passed into the decorated method, and returns anything.
+ * The result of this function will be used as the key to cache the `Promise`. By default the first element in the argument
+ * list will be used.
+ *
+ * This is a decorator for async methods. Decorated methods will return the same `Promise` for
+ * the same arguments, provided that the cached `Promise` is still pending.
+ */
+function CachePromise(getCacheKey = args => args[0]) {
+    return (_target, _key, descripter) => {
+        const promises = new Map();
+        const decoratedMethod = descripter.value;
+        // The `function` syntax is used to preserve `this` context from the decorated method.
+        descripter.value = function (...args) {
+            const cacheKey = getCacheKey(args);
+            if (promises.has(cacheKey)) {
+                return promises.get(cacheKey);
+            }
+            const ans = decoratedMethod.apply(this, args)
+                .then(ans => (promises.delete(cacheKey), ans), e => (promises.delete(cacheKey), Promise.reject(e)));
+            promises.set(cacheKey, ans);
+            return ans;
+        };
+        return descripter;
+    };
+}
+exports.CachePromise = CachePromise;
+/**
+ * This is a decorator for async methods. Decorated methods will return the same `Promise` no matter what.
+ */
+const SingletonPromise = (_target, _key, descripter) => {
+    let promise;
+    const decoratedMethod = descripter.value;
+    // The `function` syntax is used to preserve `this` context from the decorated method.
+    descripter.value = function (...args) {
+        return promise ?? (promise = decoratedMethod.apply(this, args));
+    };
+    return descripter;
+};
+exports.SingletonPromise = SingletonPromise;
+/**
+ * @param getKey A function that takes the actual arguments being passed into the decorated method, and returns anything.
+ * The result of this function will be used as the key to cache the `Timeout`. By default the first element in the argument
+ * list will be used.
+ *
+ * Decorated methods will be scheduled to run after `ms` milliseconds. The timer will reset when the method is called again.
+ */
+function Delay(ms, getKey = args => args[0]) {
+    return (_target, _key, descripter) => {
+        const timeouts = new Map();
+        const decoratedMethod = descripter.value;
+        // The `function` syntax is used to preserve `this` context from the decorated method.
+        descripter.value = function (...args) {
+            const key = getKey(args);
+            if (timeouts.has(key)) {
+                clearTimeout(timeouts.get(key));
+            }
+            timeouts.set(key, setTimeout(() => {
+                timeouts.delete(key);
+                decoratedMethod.apply(this, args);
+            }, ms));
+        };
+        return descripter;
+    };
+}
+exports.Delay = Delay;
+var SpyglassUri;
+(function (SpyglassUri) {
+    SpyglassUri.Protocol = 'spyglassmc:';
+    let Archive;
+    (function (Archive) {
+        Archive.Hostname = 'archive';
+        function get(archiveUri, pathInArchive = '') {
+            return `${SpyglassUri.Protocol}//${Archive.Hostname}/${encodeURIComponent(archiveUri)}/${pathInArchive.replace(/\\/g, '/')}`;
+        }
+        Archive.get = get;
+        function is(uri) {
+            return uri.protocol === SpyglassUri.Protocol && uri.hostname === Archive.Hostname;
+        }
+        Archive.is = is;
+        /**
+         * @throws When `uri` has the wrong protocol or hostname.
+         */
+        function decode(uri) {
+            if (uri.protocol !== SpyglassUri.Protocol) {
+                throw new Error(`Expected protocol “${SpyglassUri.Protocol}” in “${uri.toString()}”`);
+            }
+            if (uri.hostname !== Archive.Hostname) {
+                throw new Error(`Expected hostname “${Archive.Hostname}” in “${uri.toString()}”`);
+            }
+            // Ex. `pathname`: `/QzpcYS50YXIuZ3o=/foo/bar.json`
+            const paths = uri.pathname.split('/');
+            return {
+                archiveUri: decodeURIComponent(paths[1]),
+                pathInArchive: paths.slice(2).join('/'),
+            };
+        }
+        Archive.decode = decode;
+    })(Archive = SpyglassUri.Archive || (SpyglassUri.Archive = {}));
+})(SpyglassUri = exports.SpyglassUri || (exports.SpyglassUri = {}));
+var ResourceLocation;
+(function (ResourceLocation) {
+    /**
+     * The prefix for tags.
+     */
+    ResourceLocation.TagPrefix = '#';
+    /**
+     * The seperator of namespace and path.
+     */
+    ResourceLocation.NamespacePathSep = ':';
+    /**
+     * The seperator between different path segments.
+     */
+    ResourceLocation.PathSep = '/';
+    ResourceLocation.DefaultNamespace = 'minecraft';
+    function lengthen(value) {
+        switch (value.indexOf(ResourceLocation.NamespacePathSep)) {
+            case -1:
+                return `${ResourceLocation.DefaultNamespace}${ResourceLocation.NamespacePathSep}${value}`;
+            case 0:
+                return `${ResourceLocation.DefaultNamespace}${value}`;
+            default:
+                return value;
+        }
+    }
+    ResourceLocation.lengthen = lengthen;
+    function shorten(value) {
+        return value.replace(/^(?:minecraft)?:/, '');
+    }
+    ResourceLocation.shorten = shorten;
+})(ResourceLocation = exports.ResourceLocation || (exports.ResourceLocation = {}));
+/**
+ * @returns The string value decoded from the buffer according to UTF-8.
+ * Byte order mark is correctly removed.
+ */
+function bufferToString(buffer) {
+    const ans = buffer.toString('utf-8');
+    if (ans.charCodeAt(0) === 0xFEFF) {
+        return ans.slice(1);
+    }
+    return ans;
+}
+exports.bufferToString = bufferToString;
+function stringToBase64(str) {
+    return Buffer.from(str).toString('base64');
+}
+exports.stringToBase64 = stringToBase64;
+function base64ToString(base64) {
+    return Buffer.from(base64, 'base64').toString('utf-8');
+}
+exports.base64ToString = base64ToString;
+/**
+ * @throws
+ */
+function getSha1(data) {
+    const hash = crypto_1.default.createHash('sha1');
+    hash.update(data);
+    return hash.digest('hex');
+}
+exports.getSha1 = getSha1;
+function isErrorCode(e, code) {
+    return e instanceof Error && e.code === code;
+}
+exports.isErrorCode = isErrorCode;
+function isEnoent(e) {
+    return isErrorCode(e, 'ENOENT');
+}
+exports.isEnoent = isEnoent;
+var Arrayable;
+(function (Arrayable) {
+    function is(value, isT) {
+        return Array.isArray(value)
+            ? value.every(e => isT(e))
+            : isT(value);
+    }
+    Arrayable.is = is;
+    function toArray(value) {
+        return Array.isArray(value) ? value : [value];
+    }
+    Arrayable.toArray = toArray;
+})(Arrayable = exports.Arrayable || (exports.Arrayable = {}));
+var TypePredicates;
+(function (TypePredicates) {
+    function isString(value) {
+        return typeof value === 'string';
+    }
+    TypePredicates.isString = isString;
+})(TypePredicates = exports.TypePredicates || (exports.TypePredicates = {}));
+function promisifyAsyncIterable(iterable, joiner) {
+    return (async () => {
+        const chunks = [];
+        for await (const chunk of iterable) {
+            chunks.push(chunk);
+        }
+        return joiner(chunks);
+    })();
+}
+exports.promisifyAsyncIterable = promisifyAsyncIterable;
+exports.unzip = (0, util_1.promisify)(zlib_1.default.gunzip);
+exports.zip = (0, util_1.promisify)(zlib_1.default.gzip);
+async function parseGzippedJson(buffer) {
+    return JSON.parse(bufferToString(await (0, exports.unzip)(buffer)));
+}
+exports.parseGzippedJson = parseGzippedJson;
+function isObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+exports.isObject = isObject;
+function merge(a, b) {
+    const ans = (0, rfdc_1.default)()(a);
+    for (const [key, value] of Object.entries(b)) {
+        if (isObject(ans[key]) && isObject(value)) {
+            ans[key] = merge(ans[key], value);
+        }
+        else if (value === undefined) {
+            delete ans[key];
+        }
+        else {
+            ans[key] = value;
+        }
+    }
+    return ans;
+}
+exports.merge = merge;
+var Lazy;
+(function (Lazy) {
+    const LazyDiscriminator = Symbol('LazyDiscriminator');
+    function create(getter) {
+        return {
+            discriminator: LazyDiscriminator,
+            getter,
+        };
+    }
+    Lazy.create = create;
+    function isComplex(lazy) {
+        return lazy?.discriminator === LazyDiscriminator;
+    }
+    Lazy.isComplex = isComplex;
+    function isUnresolved(lazy) {
+        return isComplex(lazy) && !('value' in lazy);
+    }
+    Lazy.isUnresolved = isUnresolved;
+    function resolve(lazy) {
+        return isUnresolved(lazy) ? lazy.value = lazy.getter() : lazy;
+    }
+    Lazy.resolve = resolve;
+})(Lazy = exports.Lazy || (exports.Lazy = {}));
+/**
+ * @param ids An array of block/fluid IDs, with or without the namespace.
+ * @returns A map from state names to the corresponding sets of values. The first element in the value array is the default
+ * value for that state.
+ */
+function getStates(category, ids, ctx) {
+    const ans = {};
+    ids = ids.map(ResourceLocation.lengthen);
+    for (const id of ids) {
+        ctx.symbols
+            .query(ctx.doc, category, id)
+            .forEachMember((state, stateQuery) => {
+            const values = Object.keys(stateQuery.visibleMembers);
+            const set = ans[state] ?? (ans[state] = new Set());
+            const defaultValue = stateQuery.symbol?.relations?.default;
+            if (defaultValue) {
+                set.add(defaultValue.path[defaultValue.path.length - 1]);
+            }
+            for (const value of values) {
+                set.add(value);
+            }
+        });
+    }
+    return Object.fromEntries(Object.entries(ans).map(([k, v]) => [k, [...v]]));
+}
+exports.getStates = getStates;
+exports.binarySearch = binary_search_1.default;
+function isIterable(value) {
+    return !!value[Symbol.iterator];
+}
+exports.isIterable = isIterable;
+//# sourceMappingURL=util.js.map

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './common';
+export * from './node';
+export * from './parser';
+export * from './processor';
+export * from './service';
+export * from './source';
+export * from './symbol';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,20 @@
+"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("./common"), exports);
+__exportStar(require("./node"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./processor"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./source"), exports);
+__exportStar(require("./symbol"), exports);
+//# sourceMappingURL=index.js.map

package/lib/node/AstNode.d.ts

@@ -0,0 +1,64 @@
+import type { Color, FormattableColor } from '../processor';
+import { Range } from '../source';
+import type { Symbol, SymbolTable } from '../symbol';
+export interface AstNode {
+    readonly type: string;
+    readonly range: Range;
+    /**
+     * All child nodes of this AST node.
+     */
+    readonly children?: AstNode[];
+    readonly parent?: AstNode;
+    locals?: SymbolTable;
+    symbol?: Symbol;
+    hover?: string;
+    /**
+     * An actual color that this node represents.
+     */
+    color?: Color | FormattableColor;
+}
+export declare namespace AstNode {
+    export function is(obj: unknown): obj is AstNode;
+    export function setParents(node: AstNode): void;
+    /**
+     * @param endInclusive Defaults to `false`.
+     */
+    export function findChildIndex(node: AstNode, needle: number | Range, endInclusive?: boolean): number;
+    /**
+     * @param endInclusive Defaults to `false`.
+     */
+    export function findChild<N extends AstNode>(node: N, needle: number | Range, endInclusive?: boolean): Exclude<N['children'], undefined>[number] | undefined;
+    /**
+     * Returns the index of the last child node that ends before the `needle`.
+     *
+     * @param endInclusive Defaults to `false`.
+     */
+    export function findLastChildIndex(node: AstNode, needle: number | Range, endInclusive?: boolean): number;
+    /**
+     * @param endInclusive Defaults to `false`.
+     */
+    export function findLastChild<N extends AstNode>(node: N, needle: number | Range, endInclusive?: boolean): (N['children'] extends unknown[] ? N['children'][number] : undefined) | undefined;
+    interface FindRecursivelyOptions<P = (node: AstNode) => boolean> {
+        node: AstNode;
+        needle: number;
+        endInclusive?: boolean;
+        predicate?: P;
+    }
+    /**
+     * @returns The deepest node that both contains `needle` and satisfies the `predicate`.
+     */
+    export function findDeepestChild<N extends AstNode>(options: FindRecursivelyOptions<(node: AstNode) => node is N>): N | undefined;
+    export function findDeepestChild(options: FindRecursivelyOptions): AstNode | undefined;
+    /**
+     * @returns The shallowest node that both contains `needle` and satisfies the `predicate`.
+     */
+    export function findShallowestChild<N extends AstNode>(options: FindRecursivelyOptions<(node: AstNode) => node is N>): N | undefined;
+    export function findShallowestChild(options: FindRecursivelyOptions): AstNode | undefined;
+    export function getLocalsToRoot(node: AstNode): Generator<SymbolTable>;
+    export function getLocalsToLeaves(node: AstNode): Generator<SymbolTable>;
+    export {};
+}
+export declare type Mutable<N> = N extends AstNode ? {
+    -readonly [K in keyof N]: Mutable<N[K]>;
+} : N;
+//# sourceMappingURL=AstNode.d.ts.map

package/lib/node/AstNode.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstNode = void 0;
+const binary_search_1 = __importDefault(require("binary-search"));
+const source_1 = require("../source");
+var AstNode;
+(function (AstNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return !!obj && typeof obj === 'object' && typeof obj.type === 'string' &&
+            source_1.Range.is(obj.range);
+    }
+    AstNode.is = is;
+    function setParents(node) {
+        for (const child of node.children ?? []) {
+            child.parent = node;
+            setParents(child);
+        }
+    }
+    AstNode.setParents = setParents;
+    /**
+     * @param endInclusive Defaults to `false`.
+     */
+    function findChildIndex(node, needle, endInclusive = false) {
+        if (!node.children) {
+            return -1;
+        }
+        const comparator = typeof needle === 'number' ? source_1.Range.compareOffset : source_1.Range.compare;
+        return (0, binary_search_1.default)(node.children, needle, (a, b) => comparator(a.range, b, endInclusive));
+    }
+    AstNode.findChildIndex = findChildIndex;
+    /**
+     * @param endInclusive Defaults to `false`.
+     */
+    function findChild(node, needle, endInclusive = false) {
+        return node.children?.[findChildIndex(node, needle, endInclusive)];
+    }
+    AstNode.findChild = findChild;
+    /**
+     * Returns the index of the last child node that ends before the `needle`.
+     *
+     * @param endInclusive Defaults to `false`.
+     */
+    function findLastChildIndex(node, needle, endInclusive = false) {
+        if (!node.children) {
+            return -1;
+        }
+        let ans = -1;
+        for (const [i, childNode] of node.children.entries()) {
+            if (source_1.Range.endsBefore(childNode.range, needle, endInclusive)) {
+                ans = i;
+            }
+            else {
+                break;
+            }
+        }
+        return ans;
+    }
+    AstNode.findLastChildIndex = findLastChildIndex;
+    /**
+     * @param endInclusive Defaults to `false`.
+     */
+    function findLastChild(node, needle, endInclusive = false) {
+        return node.children?.[findLastChildIndex(node, needle, endInclusive)];
+    }
+    AstNode.findLastChild = findLastChild;
+    function findDeepestChild({ node, needle, endInclusive = false, predicate = () => true }) {
+        let last;
+        let head = source_1.Range.contains(node, needle, endInclusive) ? node : undefined;
+        while (head && predicate(head)) {
+            last = head;
+            head = findChild(head, needle, endInclusive);
+        }
+        return last;
+    }
+    AstNode.findDeepestChild = findDeepestChild;
+    function findShallowestChild({ node, needle, endInclusive = false, predicate = () => true }) {
+        let head = source_1.Range.contains(node, needle, endInclusive) ? node : undefined;
+        while (head && !predicate(head)) {
+            head = findChild(head, needle, endInclusive);
+        }
+        return head;
+    }
+    AstNode.findShallowestChild = findShallowestChild;
+    function* getLocalsToRoot(node) {
+        let head = node;
+        while (head) {
+            if (head.locals) {
+                yield head.locals;
+            }
+            head = node.parent;
+        }
+    }
+    AstNode.getLocalsToRoot = getLocalsToRoot;
+    function* getLocalsToLeaves(node) {
+        if (node.locals) {
+            yield node.locals;
+        }
+        for (const child of node.children ?? []) {
+            yield* getLocalsToLeaves(child);
+        }
+    }
+    AstNode.getLocalsToLeaves = getLocalsToLeaves;
+})(AstNode = exports.AstNode || (exports.AstNode = {}));
+//# sourceMappingURL=AstNode.js.map

package/lib/node/BooleanNode.d.ts

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