@spyglassmc/core 0.4.5 → 0.4.7

package/lib/common/Dev.js

@@ -30,8 +30,7 @@ export var Dev;
             switch (typeof current) {
                 case 'bigint': {
                     const bits = Math.ceil(Math.log2(Number(current)));
-                    ans += (2 + Math.ceil(bits / (ByteToBits * PointerSize))) *
-                        PointerSize; // https://stackoverflow.com/a/54298760
+                    ans += (2 + Math.ceil(bits / (ByteToBits * PointerSize))) * PointerSize; // https://stackoverflow.com/a/54298760
                     break;
                 }
                 case 'boolean':
@@ -81,9 +80,7 @@ export var Dev;
             catch (ignored) {
                 // Most likely "Maximum callstack size exceeded".
                 // Fall back to a shallow string representation.
-                return `{ ${Object.entries(value)
-                    .map(([k, v]) => `'${k}': '${String(v)}'`)
-                    .join(', ')} }`;
+                return `{ ${Object.entries(value).map(([k, v]) => `'${k}': '${String(v)}'`).join(', ')} }`;
             }
         }
         else if (typeof value === 'symbol') {

package/lib/common/ReadonlyProxy.js

@@ -11,9 +11,7 @@ class ReadonlyProxyHandler {
     get(target, p, receiver) {
         const value = Reflect.get(target, p, receiver);
         if (p !== 'prototype' && isObject(value)) {
-            return emplaceMap(this.map, p, {
-                insert: () => ReadonlyProxy.create(value),
-            });
+            return emplaceMap(this.map, p, { insert: () => ReadonlyProxy.create(value) });
         }
         return value;
     }

package/lib/common/StateProxy.js

@@ -63,18 +63,12 @@ class StateProxyHandler {
         }
         const value = Reflect.get(target, p, receiver);
         if (p !== 'prototype' && isObject(value)) {
-            return emplaceMap(this.map, p, {
-                insert: () => _createStateProxy(value, this.rootOps),
-            });
+            return emplaceMap(this.map, p, { insert: () => _createStateProxy(value, this.rootOps) });
         }
         return value;
     }
     set(target, p, value, receiver) {
-        if (p === BranchOff ||
-            p === Is ||
-            p === Origin ||
-            p === Redo ||
-            p === Undo) {
+        if (p === BranchOff || p === Is || p === Origin || p === Redo || p === Undo) {
             throw new TypeError(`Cannot set ${String(p)}`);
         }
         this.rootOps.set(target, p, StateProxy.dereference(value), receiver);

package/lib/common/externals/BrowserExternals.js

@@ -1,4 +1,4 @@
-import { decode as arrayBufferFromBase64, encode as arrayBufferToBase64, } from 'base64-arraybuffer';
+import { decode as arrayBufferFromBase64, encode as arrayBufferToBase64 } from 'base64-arraybuffer';
 import pako from 'pako';
 import { fileUtil } from '../../service/fileUtil.js';
 class BrowserEventEmitter {
@@ -44,10 +44,7 @@ class BrowserExternalDownloader {
                 headers.append(name, v);
             }
         }
-        const res = await fetch(uri, {
-            headers,
-            redirect: 'follow',
-        });
+        const res = await fetch(uri, { headers, redirect: 'follow' });
         if (!res.ok) {
             throw new Error(`Status code ${res.status}: ${res.ok}`);
         }
@@ -114,10 +111,7 @@ class BrowserFileSystem {
         if (!entry) {
             throw new Error(`ENOENT: ${location}`);
         }
-        return {
-            isDirectory: () => entry.type === 'directory',
-            isFile: () => entry.type === 'file',
-        };
+        return { isDirectory: () => entry.type === 'directory', isFile: () => entry.type === 'file' };
     }
     async unlink(location) {
         location = location.toString();
@@ -164,13 +158,14 @@ export const BrowserExternals = {
     },
     downloader: new BrowserExternalDownloader(),
     error: {
+        createKind(kind, message) {
+            return new Error(`${kind}: ${message}`);
+        },
         isKind(e, kind) {
             return e instanceof Error && e.message.startsWith(kind);
         },
     },
-    event: {
-        EventEmitter: BrowserEventEmitter,
-    },
+    event: { EventEmitter: BrowserEventEmitter },
     fs: new BrowserFileSystem(),
 };
 function uint8ArrayToHex(array) {

package/lib/common/externals/NodeJsExternals.js

@@ -28,6 +28,8 @@ class NodeJsExternalDownloader {
                 else {
                     resolve(promisifyAsyncIterable(res, (chunks) => Buffer.concat(chunks)));
                 }
+            }).on('error', (e) => {
+                reject(e);
             });
         });
     }
@@ -56,22 +58,24 @@ export const NodeJsExternals = {
     },
     downloader: new NodeJsExternalDownloader(),
     error: {
+        createKind(kind, message) {
+            const error = new Error(message);
+            error.code = kind;
+            return error;
+        },
         isKind(e, kind) {
             return e instanceof Error && e.code === kind;
         },
     },
-    event: {
-        EventEmitter,
-    },
+    event: { EventEmitter },
     fs: {
         chmod(location, mode) {
             return fsp.chmod(toFsPathLike(location), mode);
         },
-        async getAllFiles(location) {
-            return (await globby(toPath(location) + '**/*', {
-                absolute: true,
-                dot: true,
-            })).map(uriFromPath);
+        async getAllFiles(location, depth) {
+            const path = toPath(location).replaceAll('\\', '/') + '**/*';
+            const files = await globby(path, { absolute: true, dot: true, deep: depth });
+            return files.map(uriFromPath);
         },
         async mkdir(location, options) {
             return void (await fsp.mkdir(toFsPathLike(location), options));

package/lib/common/externals/index.d.ts

@@ -17,6 +17,13 @@ export interface Externals {
     };
     downloader: ExternalDownloader;
     error: {
+        /**
+         * @returns an error of the specified kind
+         */
+        createKind: (kind: ExternalErrorKind, message: string) => unknown;
+        /**
+         * Checks whether the given error is of a certain kind
+         */
         isKind: (e: unknown, kind: ExternalErrorKind) => boolean;
     };
     event: {
@@ -45,7 +52,7 @@ export interface ExternalFileSystem {
     /**
      * @returns an array of file URIs under the given `location`.
      */
-    getAllFiles(location: FsLocation): Promise<string[]>;
+    getAllFiles(location: FsLocation, depth?: number): Promise<string[]>;
     /**
      * @param options `mode` - File mode bit mask (e.g. `0o775`).
      */

package/lib/common/util.js

@@ -171,10 +171,7 @@ export var Lazy;
 (function (Lazy) {
     const LazyDiscriminator = Symbol('LazyDiscriminator');
     function create(getter) {
-        return {
-            discriminator: LazyDiscriminator,
-            getter,
-        };
+        return { discriminator: LazyDiscriminator, getter };
     }
     Lazy.create = create;
     function isComplex(lazy) {
@@ -186,9 +183,7 @@ export var Lazy;
     }
     Lazy.isUnresolved = isUnresolved;
     function resolve(lazy) {
-        return isUnresolved(lazy)
-            ? (lazy.value = lazy.getter())
-            : lazy;
+        return isUnresolved(lazy) ? (lazy.value = lazy.getter()) : lazy;
     }
     Lazy.resolve = resolve;
 })(Lazy || (Lazy = {}));
@@ -201,9 +196,7 @@ export 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) => {
+        ctx.symbols.query(ctx.doc, category, id).forEachMember((state, stateQuery) => {
             const values = Object.keys(stateQuery.visibleMembers);
             const set = (ans[state] ??= new Set());
             const defaultValue = stateQuery.symbol?.relations?.default;

package/lib/node/AstNode.js

@@ -4,10 +4,10 @@ export var AstNode;
 (function (AstNode) {
     /* istanbul ignore next */
     function is(obj) {
-        return (!!obj &&
-            typeof obj === 'object' &&
-            typeof obj.type === 'string' &&
-            Range.is(obj.range));
+        return (!!obj
+            && typeof obj === 'object'
+            && typeof obj.type === 'string'
+            && Range.is(obj.range));
     }
     AstNode.is = is;
     function setParents(node) {
@@ -24,9 +24,7 @@ export var AstNode;
         if (!node.children) {
             return -1;
         }
-        const comparator = typeof needle === 'number'
-            ? Range.compareOffset
-            : Range.compare;
+        const comparator = typeof needle === 'number' ? Range.compareOffset : Range.compare;
         return binarySearch(node.children, needle, (a, b) => comparator(a.range, b, endInclusive));
     }
     AstNode.findChildIndex = findChildIndex;
@@ -65,7 +63,7 @@ export var AstNode;
         return node.children?.[findLastChildIndex(node, needle, endInclusive)];
     }
     AstNode.findLastChild = findLastChild;
-    function findDeepestChild({ node, needle, endInclusive = false, predicate = () => true, }) {
+    function findDeepestChild({ node, needle, endInclusive = false, predicate = () => true }) {
         let last;
         let head = Range.contains(node, needle, endInclusive) ? node : undefined;
         while (head && predicate(head)) {
@@ -75,7 +73,7 @@ export var AstNode;
         return last;
     }
     AstNode.findDeepestChild = findDeepestChild;
-    function findShallowestChild({ node, needle, endInclusive = false, predicate = () => true, }) {
+    function findShallowestChild({ node, needle, endInclusive = false, predicate = () => true }) {
         let head = Range.contains(node, needle, endInclusive) ? node : undefined;
         while (head && !predicate(head)) {
             head = findChild(head, needle, endInclusive);

package/lib/node/BooleanNode.js

@@ -7,10 +7,7 @@ export var BooleanNode;
     }
     BooleanNode.is = is;
     function mock(range) {
-        return {
-            type: 'boolean',
-            range: Range.get(range),
-        };
+        return { type: 'boolean', range: Range.get(range) };
     }
     BooleanNode.mock = mock;
 })(BooleanNode || (BooleanNode = {}));

package/lib/node/FloatNode.js

@@ -7,11 +7,7 @@ export var FloatNode;
     }
     FloatNode.is = is;
     function mock(range) {
-        return {
-            type: 'float',
-            range: Range.get(range),
-            value: 0,
-        };
+        return { type: 'float', range: Range.get(range), value: 0 };
     }
     FloatNode.mock = mock;
 })(FloatNode || (FloatNode = {}));

package/lib/node/IntegerNode.js

@@ -6,11 +6,7 @@ export var IntegerNode;
     }
     IntegerNode.is = is;
     function mock(range) {
-        return {
-            type: 'integer',
-            range: Range.get(range),
-            value: 0,
-        };
+        return { type: 'integer', range: Range.get(range), value: 0 };
     }
     IntegerNode.mock = mock;
 })(IntegerNode || (IntegerNode = {}));

package/lib/node/ListNode.d.ts

@@ -10,6 +10,6 @@ export interface ItemNode<V extends AstNode> extends AstNode {
     readonly sep?: Range;
 }
 export declare namespace ItemNode {
-    function is<V extends AstNode>(node: AstNode | undefined): node is ItemNode<V>;
+    function is<V extends AstNode>(node: object | undefined): node is ItemNode<V>;
 }
 //# sourceMappingURL=ListNode.d.ts.map

package/lib/node/LiteralNode.js

@@ -7,12 +7,7 @@ export var LiteralNode;
     }
     LiteralNode.is = is;
     function mock(range, options) {
-        return {
-            type: 'literal',
-            range: Range.get(range),
-            options,
-            value: '',
-        };
+        return { type: 'literal', range: Range.get(range), options, value: '' };
     }
     LiteralNode.mock = mock;
 })(LiteralNode || (LiteralNode = {}));

package/lib/node/LongNode.js

@@ -6,11 +6,7 @@ export var LongNode;
     }
     LongNode.is = is;
     function mock(range) {
-        return {
-            type: 'long',
-            range: Range.get(range),
-            value: 0n,
-        };
+        return { type: 'long', range: Range.get(range), value: 0n };
     }
     LongNode.mock = mock;
 })(LongNode || (LongNode = {}));

package/lib/node/PrefixedNode.d.ts

@@ -0,0 +1,13 @@
+import type { RangeLike } from '../source/index.js';
+import type { AstNode } from './AstNode.js';
+import { LiteralNode } from './LiteralNode.js';
+export interface PrefixedNode<C extends AstNode = AstNode> extends AstNode {
+    readonly type: 'prefixed';
+    readonly children: (LiteralNode | C)[];
+    readonly prefix: string;
+}
+export declare namespace PrefixedNode {
+    function is<C extends AstNode>(obj: object): obj is PrefixedNode<C>;
+    function mock<C extends AstNode>(range: RangeLike, prefix: string, child: C): PrefixedNode<C>;
+}
+//# sourceMappingURL=PrefixedNode.d.ts.map

package/lib/node/PrefixedNode.js

@@ -0,0 +1,22 @@
+import { Range } from '../source/index.js';
+import { LiteralNode } from './LiteralNode.js';
+export var PrefixedNode;
+(function (PrefixedNode) {
+    function is(obj) {
+        return obj.type === 'prefixed';
+    }
+    PrefixedNode.is = is;
+    function mock(range, prefix, child) {
+        return {
+            type: 'prefixed',
+            range: Range.get(range),
+            prefix,
+            children: [
+                LiteralNode.mock(range, { pool: [prefix] }),
+                child,
+            ],
+        };
+    }
+    PrefixedNode.mock = mock;
+})(PrefixedNode || (PrefixedNode = {}));
+//# sourceMappingURL=PrefixedNode.js.map

package/lib/node/ResourceLocationNode.d.ts

@@ -5,23 +5,26 @@ import type { ResourceLocationCategory, SymbolAccessType, SymbolUsageType, Tagga
 import type { AstNode } from './AstNode.js';
 export type ResourceLocationOptions = {
     accessType?: SymbolAccessType;
-    isPredicate?: boolean;
+    requireCanonical?: boolean;
     usageType?: SymbolUsageType;
     namespacePathSep?: ':' | '.';
 } & ({
     category: ResourceLocationCategory;
     pool?: undefined;
     allowTag?: false;
+    requireTag?: false;
     allowUnknown?: false;
 } | {
     category: TaggableResourceLocationCategory;
     pool?: undefined;
     allowTag?: boolean;
+    requireTag?: boolean;
     allowUnknown?: false;
 } | {
     category?: undefined;
     pool: string[];
     allowTag?: false;
+    requireTag?: false;
     allowUnknown?: boolean;
 });
 export interface ResourceLocationBaseNode extends AstNode, Partial<ResourceLocation> {

package/lib/node/ResourceLocationNode.js

@@ -21,11 +21,7 @@ export var ResourceLocationNode;
     }
     ResourceLocationNode.is = is;
     function mock(range, options) {
-        return {
-            type: 'resource_location',
-            range: Range.get(range),
-            options,
-        };
+        return { type: 'resource_location', range: Range.get(range), options };
     }
     ResourceLocationNode.mock = mock;
     function toString(node, type = 'origin', includesTagPrefix = false) {
@@ -43,9 +39,7 @@ export var ResourceLocationNode;
         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;
+                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.

package/lib/node/StringNode.d.ts

@@ -7,7 +7,7 @@ export 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 const EscapeTable: Map<"\"" | "'" | "\\" | "b" | "f" | "n" | "r" | "t", string>;
 export type Quote = "'" | '"';
 export interface StringOptions {
     colorTokenType?: ColorTokenType;
@@ -50,6 +50,7 @@ export interface StringOptions {
 export type QuoteTypeConfig = 'always double' | 'always single' | 'prefer double' | 'prefer single';
 export interface StringBaseNode extends AstNode {
     readonly options: StringOptions;
+    quote?: Quote;
     value: string;
     readonly valueMap: IndexMap;
 }

package/lib/node/StringNode.js

@@ -32,10 +32,7 @@ export var StringNode;
             range,
             options,
             value: '',
-            valueMap: [{
-                    inner: Range.create(0),
-                    outer: Range.create(range.start),
-                }],
+            valueMap: [{ inner: Range.create(0), outer: Range.create(range.start) }],
         };
     }
     StringNode.mock = mock;

package/lib/node/SymbolNode.js

@@ -7,12 +7,7 @@ export var SymbolNode;
     }
     SymbolNode.is = is;
     function mock(range, options) {
-        return {
-            type: 'symbol',
-            range: Range.get(range),
-            options,
-            value: '',
-        };
+        return { type: 'symbol', range: Range.get(range), options, value: '' };
     }
     SymbolNode.mock = mock;
 })(SymbolNode || (SymbolNode = {}));

package/lib/node/index.d.ts

@@ -8,6 +8,7 @@ export * from './IntegerNode.js';
 export * from './ListNode.js';
 export * from './LiteralNode.js';
 export * from './LongNode.js';
+export * from './PrefixedNode.js';
 export * from './RecordNode.js';
 export * from './ResourceLocationNode.js';
 export * from './Sequence.js';

package/lib/node/index.js

@@ -8,6 +8,7 @@ export * from './IntegerNode.js';
 export * from './ListNode.js';
 export * from './LiteralNode.js';
 export * from './LongNode.js';
+export * from './PrefixedNode.js';
 export * from './RecordNode.js';
 export * from './ResourceLocationNode.js';
 export * from './Sequence.js';

package/lib/parser/comment.d.ts

@@ -7,6 +7,6 @@ interface Options {
 /**
  * `Failure` when three isn't a comment.
  */
-export declare function comment({ singleLinePrefixes, includesEol, }: Options): Parser<CommentNode>;
+export declare function comment({ singleLinePrefixes, includesEol }: Options): Parser<CommentNode>;
 export {};
 //# sourceMappingURL=comment.d.ts.map

package/lib/parser/comment.js

@@ -3,14 +3,10 @@ import { Failure } from './Parser.js';
 /**
  * `Failure` when three isn't a comment.
  */
-export function comment({ singleLinePrefixes, includesEol, }) {
+export function comment({ singleLinePrefixes, includesEol }) {
     return (src, _ctx) => {
         const start = src.cursor;
-        const ans = {
-            type: 'comment',
-            range: Range.create(start),
-            comment: '',
-        };
+        const ans = { type: 'comment', range: Range.create(start), comment: '' };
         for (const prefix of singleLinePrefixes) {
             if (src.peek(prefix.length) === prefix) {
                 if (includesEol) {

package/lib/parser/error.js

@@ -8,10 +8,7 @@ export const error = (src, ctx) => {
     if (!src.canRead()) {
         return undefined;
     }
-    const ans = {
-        type: 'error',
-        range: Range.create(src, () => src.skipRemaining()),
-    };
+    const ans = { type: 'error', range: Range.create(src, () => src.skipRemaining()) };
     ctx.err.report(localize('error.unparseable-content'), ans);
     return ans;
 };

package/lib/parser/file.d.ts

@@ -1,9 +1,9 @@
 import type { FileNode } from '../node/index.js';
 import { AstNode } from '../node/index.js';
-import type { InfallibleParser } from './Parser.js';
+import type { InfallibleParser, Parser } from './Parser.js';
 /**
  * Dispatches to the corresponding parser for the language.
  * @throws If there's no parser registered for this language ID.
  */
-export declare function file(): InfallibleParser<FileNode<AstNode>>;
+export declare function file(parser: Parser<AstNode>): InfallibleParser<FileNode<AstNode>>;
 //# sourceMappingURL=file.d.ts.map

package/lib/parser/file.js

@@ -6,7 +6,7 @@ import { Failure } from './Parser.js';
  * Dispatches to the corresponding parser for the language.
  * @throws If there's no parser registered for this language ID.
  */
-export function file() {
+export function file(parser) {
     return (src, ctx) => {
         const fullRange = Range.create(src, src.string.length);
         const ans = {
@@ -17,7 +17,6 @@ export function file() {
             parserErrors: [],
         };
         src.skipWhitespace();
-        const parser = ctx.meta.getParserForLanguageId(ctx.doc.languageId);
         const result = parser(src, ctx);
         if (result && result !== Failure) {
             ans.children.push(result);

package/lib/parser/float.js

@@ -6,11 +6,7 @@ const fallbackOnOutOfRange = (ans, _src, ctx, options) => {
 };
 export function float(options) {
     return (src, ctx) => {
-        const ans = {
-            type: 'float',
-            range: Range.create(src),
-            value: 0,
-        };
+        const ans = { type: 'float', range: Range.create(src), value: 0 };
         if (src.peek() === '-' || src.peek() === '+') {
             src.skip();
         }
@@ -43,8 +39,7 @@ export function float(options) {
         else if (!options.pattern.test(raw)) {
             ctx.err.report(localize('parser.float.illegal', options.pattern), ans);
         }
-        else if ((options.min && ans.value < options.min) ||
-            (options.max && ans.value > options.max)) {
+        else if ((options.min && ans.value < options.min) || (options.max && ans.value > options.max)) {
             const onOutOfRange = options.onOutOfRange ?? fallbackOnOutOfRange;
             onOutOfRange(ans, src, ctx, options);
         }

package/lib/parser/index.d.ts

@@ -9,6 +9,7 @@ export { list } from './list.js';
 export * from './literal.js';
 export { long } from './long.js';
 export * from './Parser.js';
+export * from './prefixed.js';
 export { record } from './record.js';
 export * from './resourceLocation.js';
 export * from './string.js';

package/lib/parser/index.js

@@ -10,6 +10,7 @@ export { list } from './list.js';
 export * from './literal.js';
 export { long } from './long.js';
 export * from './Parser.js';
+export * from './prefixed.js';
 export { record } from './record.js';
 export * from './resourceLocation.js';
 export * from './string.js';

package/lib/parser/integer.js

@@ -6,11 +6,7 @@ const fallbackOnOutOfRange = (ans, _src, ctx, options) => {
 };
 export function integer(options) {
     return (src, ctx) => {
-        const ans = {
-            type: 'integer',
-            range: Range.create(src),
-            value: 0,
-        };
+        const ans = { type: 'integer', range: Range.create(src), value: 0 };
         if (src.peek() === '-' || src.peek() === '+') {
             src.skip();
         }
@@ -32,8 +28,8 @@ export function integer(options) {
         else if (!options.pattern.test(raw) || isOnlySign) {
             ctx.err.report(localize('parser.integer.illegal', options.pattern), ans);
         }
-        else if ((options.min !== undefined && ans.value < options.min) ||
-            (options.max !== undefined && ans.value > options.max)) {
+        else if ((options.min !== undefined && ans.value < options.min)
+            || (options.max !== undefined && ans.value > options.max)) {
             const onOutOfRange = options.onOutOfRange ?? fallbackOnOutOfRange;
             onOutOfRange(ans, src, ctx, options);
         }

package/lib/parser/list.d.ts

@@ -8,5 +8,5 @@ export interface Options<V extends AstNode> {
     trailingSep: boolean;
     end: string;
 }
-export declare function list<V extends AstNode>({ start, value, sep, trailingSep, end, }: Options<V>): InfallibleParser<ListNode<V>>;
+export declare function list<V extends AstNode>({ start, value, sep, trailingSep, end }: Options<V>): InfallibleParser<ListNode<V>>;
 //# sourceMappingURL=list.d.ts.map

package/lib/parser/list.js

@@ -2,13 +2,9 @@ import { localeQuote, localize } from '@spyglassmc/locales';
 import { Range } from '../source/index.js';
 import { Failure } from './Parser.js';
 import { attempt } from './util.js';
-export function list({ start, value, sep, trailingSep, end, }) {
+export function list({ start, value, sep, trailingSep, end }) {
     return (src, ctx) => {
-        const ans = {
-            type: 'list',
-            range: Range.create(src),
-            children: [],
-        };
+        const ans = { type: 'list', range: Range.create(src), children: [] };
         if (src.trySkip(start)) {
             src.skipWhitespace();
             let requiresValueSep = false;