@spyglassmc/core 0.4.1 → 0.4.3

package/lib/common/Dev.d.ts

@@ -1,11 +1,11 @@
-export declare const Dev: Readonly<{
-    assertDefined<T>(value: T): asserts value is Exclude<T, undefined>;
-    assertNever(value: never): never;
-    assertTrue(value: boolean, message: string): void;
+export declare namespace Dev {
+    function assertDefined<T>(value: T): asserts value is Exclude<T, undefined>;
+    function assertNever(value: never): never;
+    function assertTrue(value: boolean, message: string): void;
     /**
      * @returns An estimate of the memory taken by the given value, assuming objects are stored as array-like structures instead of dictionaries in the V8 engine.
      */
-    estimateMemoryUsage(value: unknown): number;
-    stringify(value: unknown): string;
-}>;
+    function estimateMemoryUsage(value: unknown): number;
+    function stringify(value: unknown): string;
+}
 //# sourceMappingURL=Dev.d.ts.map

package/lib/common/Dev.js

@@ -1,21 +1,25 @@
-export const Dev = Object.freeze({
-    assertDefined(value) {
+export var Dev;
+(function (Dev) {
+    function assertDefined(value) {
         if (value === undefined) {
             throw new Error(`'${Dev.stringify(value)}' is 'undefined'`);
         }
-    },
-    assertNever(value) {
+    }
+    Dev.assertDefined = assertDefined;
+    function assertNever(value) {
         throw new Error(`'${Dev.stringify(value)}' is not of type 'never'`);
-    },
-    assertTrue(value, message) {
+    }
+    Dev.assertNever = assertNever;
+    function assertTrue(value, message) {
         if (!value) {
             throw new Error(`Assertion failed: ${message}. '${Dev.stringify(value)}' should be true.`);
         }
-    },
+    }
+    Dev.assertTrue = assertTrue;
     /**
      * @returns An estimate of the memory taken by the given value, assuming objects are stored as array-like structures instead of dictionaries in the V8 engine.
      */
-    estimateMemoryUsage(value) {
+    function estimateMemoryUsage(value) {
         const ByteToBits = 8;
         const PointerSize = 8;
         let ans = 0;
@@ -26,8 +30,8 @@ export const Dev = Object.freeze({
             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':
@@ -59,8 +63,9 @@ export const Dev = Object.freeze({
             }
         }
         return ans;
-    },
-    stringify(value) {
+    }
+    Dev.estimateMemoryUsage = estimateMemoryUsage;
+    function stringify(value) {
         if (value && typeof value === 'object') {
             try {
                 const seen = new Set();
@@ -88,6 +93,7 @@ export const Dev = Object.freeze({
         else {
             return `${value}`;
         }
-    },
-});
+    }
+    Dev.stringify = stringify;
+})(Dev || (Dev = {}));
 //# sourceMappingURL=Dev.js.map

package/lib/common/ReadonlyProxy.d.ts

@@ -1,9 +1,12 @@
-declare type Wrap<T> = T extends object ? DeepReadonly<T> : T;
-export declare type DeepReadonly<T extends object> = {
-    readonly [K in keyof T]: Wrap<T[K]>;
+type DeepReadonlyValue<T> = T extends object ? DeepReadonly<T> : T;
+export type DeepReadonly<T extends object> = {
+    readonly [K in keyof T]: DeepReadonlyValue<T[K]>;
 };
-export declare const ReadonlyProxy: Readonly<{
-    create<T extends object>(obj: T): DeepReadonly<T>;
-}>;
+export type ReadWrite<T extends object> = {
+    -readonly [K in keyof T]: T[K];
+};
+export declare namespace ReadonlyProxy {
+    function create<T extends object>(obj: T): DeepReadonly<T>;
+}
 export {};
 //# sourceMappingURL=ReadonlyProxy.d.ts.map

package/lib/common/ReadonlyProxy.js

@@ -1,9 +1,11 @@
 import { emplaceMap, isObject } from './util.js';
-export const ReadonlyProxy = Object.freeze({
-    create(obj) {
+export var ReadonlyProxy;
+(function (ReadonlyProxy) {
+    function create(obj) {
         return new Proxy(obj, new ReadonlyProxyHandler());
-    },
-});
+    }
+    ReadonlyProxy.create = create;
+})(ReadonlyProxy || (ReadonlyProxy = {}));
 class ReadonlyProxyHandler {
     map = new Map();
     get(target, p, receiver) {

package/lib/common/StateProxy.d.ts

@@ -3,7 +3,7 @@ declare const Is: unique symbol;
 declare const Origin: unique symbol;
 declare const Redo: unique symbol;
 declare const Undo: unique symbol;
-declare type Wrap<T> = T extends object ? StateProxy<T> : T;
+type Wrap<T> = T extends object ? StateProxy<T> : T;
 /**
  * A proxy wrapped around an arbitrary object value.
  * You can access and mutate the value as normal, but you also have the ability to revert all changes ever since the
@@ -12,7 +12,7 @@ declare type Wrap<T> = T extends object ? StateProxy<T> : T;
  * A new proxy can be branched off of an existing proxy using {@link StateProxy.branchOff} to have finer control
  * over what changes to be reverted.
  */
-export declare type StateProxy<T extends object> = {
+export type StateProxy<T extends object> = {
     [K in keyof T]: Wrap<T[K]>;
 } & {
     [BranchOff]: () => StateProxy<T>;
@@ -21,15 +21,15 @@ export declare type StateProxy<T extends object> = {
     [Redo]: () => void;
     [Undo]: () => void;
 };
-export declare const StateProxy: Readonly<{
-    branchOff<T extends object>(proxy: StateProxy<T>): StateProxy<T>;
-    create<T_1 extends object>(obj: T_1): T_1 extends StateProxy<any> ? void & {
+export declare namespace StateProxy {
+    function branchOff<T extends object>(proxy: StateProxy<T>): StateProxy<T>;
+    function create<T extends object>(obj: T): T extends StateProxy<any> ? void & {
         _cannotCreateProxyFromProxy: never;
-    } : StateProxy<T_1>;
-    dereference<T_2 extends object>(value: T_2 | StateProxy<T_2>): T_2;
-    is(obj: any): obj is StateProxy<object>;
-    redoChanges(proxy: StateProxy<object>): void;
-    undoChanges(proxy: StateProxy<object>): void;
-}>;
+    } : StateProxy<T>;
+    function dereference<T extends object>(value: StateProxy<T> | T): T;
+    function is(obj: any): obj is StateProxy<object>;
+    function redoChanges(proxy: StateProxy<object>): void;
+    function undoChanges(proxy: StateProxy<object>): void;
+}
 export {};
 //# sourceMappingURL=StateProxy.d.ts.map

package/lib/common/StateProxy.js

@@ -5,29 +5,36 @@ const Is = Symbol('IsStateProxy');
 const Origin = Symbol('OriginState');
 const Redo = Symbol('RedoStateChanges');
 const Undo = Symbol('UndoStateChanges');
-export const StateProxy = Object.freeze({
-    branchOff(proxy) {
+export var StateProxy;
+(function (StateProxy) {
+    function branchOff(proxy) {
         return proxy[BranchOff]();
-    },
-    create(obj) {
+    }
+    StateProxy.branchOff = branchOff;
+    function create(obj) {
         if (StateProxy.is(obj)) {
             throw new TypeError('Cannot create a proxy over a proxy. You might want to use branchOff instead.');
         }
         return _createStateProxy(obj, new Operations());
-    },
-    dereference(value) {
+    }
+    StateProxy.create = create;
+    function dereference(value) {
         return StateProxy.is(value) ? value[Origin] : value;
-    },
-    is(obj) {
+    }
+    StateProxy.dereference = dereference;
+    function is(obj) {
         return obj?.[Is];
-    },
-    redoChanges(proxy) {
+    }
+    StateProxy.is = is;
+    function redoChanges(proxy) {
         proxy[Redo]();
-    },
-    undoChanges(proxy) {
+    }
+    StateProxy.redoChanges = redoChanges;
+    function undoChanges(proxy) {
         proxy[Undo]();
-    },
-});
+    }
+    StateProxy.undoChanges = undoChanges;
+})(StateProxy || (StateProxy = {}));
 class StateProxyHandler {
     rootOps;
     map = new Map();

package/lib/common/externals/NodeJsExternals.js

@@ -68,7 +68,10 @@ export const NodeJsExternals = {
             return fsp.chmod(toFsPathLike(location), mode);
         },
         async getAllFiles(location) {
-            return (await globby(toPath(location) + '**/*', { absolute: true, dot: true })).map(uriFromPath);
+            return (await globby(toPath(location) + '**/*', {
+                absolute: true,
+                dot: true,
+            })).map(uriFromPath);
         },
         async mkdir(location, options) {
             return void (await fsp.mkdir(toFsPathLike(location), options));
@@ -111,8 +114,13 @@ Object.freeze(NodeJsExternals);
  * @returns A {@link fs.PathLike}.
  */
 function toFsPathLike(path) {
+    if (path instanceof Uri) {
+        // Convert WHATWG URL to string so that it will be converted
+        // to Node.js URL by the next if-block.
+        path = path.toString();
+    }
     if (typeof path === 'string' && path.startsWith('file:')) {
-        return new Uri(path);
+        return new url.URL(path);
     }
     return path;
 }
@@ -122,7 +130,7 @@ function toPath(path) {
     }
     return uriToPath(path);
 }
-const uriToPath = (uri) => url.fileURLToPath(uri);
+const uriToPath = (uri) => url.fileURLToPath(uri instanceof Uri ? new url.URL(uri.toString()) : uri);
 const uriFromPath = (path) => url.pathToFileURL(path).toString();
 class ChokidarWatcherWrapper extends EventEmitter {
     #watcher;

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

@@ -1,8 +1,8 @@
-declare type RemoteUriProtocol = 'http:' | 'https:';
-export declare type RemoteUriString = `${RemoteUriProtocol}${string}`;
-export declare const RemoteUriString: Readonly<{
-    is(value: string): value is `http:${string}` | `https:${string}`;
-}>;
+type RemoteUriProtocol = 'http:' | 'https:';
+export type RemoteUriString = `${RemoteUriProtocol}${string}`;
+export declare namespace RemoteUriString {
+    function is(value: string): value is RemoteUriString;
+}
 export interface ExternalDownloaderOptions {
     /**
      * Use an string array to set multiple values to the header.
@@ -16,9 +16,9 @@ export interface ExternalDownloader {
      */
     get(uri: RemoteUriString, options?: ExternalDownloaderOptions): Promise<Uint8Array>;
 }
-export declare const ExternalDownloader: Readonly<{
-    mock(options: ExternalDownloaderMockOptions): ExternalDownloader;
-}>;
+export declare namespace ExternalDownloader {
+    function mock(options: ExternalDownloaderMockOptions): ExternalDownloader;
+}
 interface ExternalDownloaderMockOptions {
     /**
      * A record from URIs to fixture data. The {@link ExternalDownloader.get} only returns a {@link Uint8Array},

package/lib/common/externals/downloader.js

@@ -1,13 +1,17 @@
-export const RemoteUriString = Object.freeze({
-    is(value) {
+export var RemoteUriString;
+(function (RemoteUriString) {
+    function is(value) {
         return value.startsWith('http:') || value.startsWith('https:');
-    },
-});
-export const ExternalDownloader = Object.freeze({
-    mock(options) {
+    }
+    RemoteUriString.is = is;
+})(RemoteUriString || (RemoteUriString = {}));
+export var ExternalDownloader;
+(function (ExternalDownloader) {
+    function mock(options) {
         return new ExternalDownloaderMock(options);
-    },
-});
+    }
+    ExternalDownloader.mock = mock;
+})(ExternalDownloader || (ExternalDownloader = {}));
 class ExternalDownloaderMock {
     options;
     constructor(options) {

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

@@ -31,7 +31,7 @@ export interface DecompressedFile {
     path: string;
     type: string;
 }
-export declare type ExternalErrorKind = 'EEXIST' | 'EISDIR' | 'ENOENT';
+export type ExternalErrorKind = 'EEXIST' | 'EISDIR' | 'ENOENT';
 export interface ExternalEventEmitter {
     emit(eventName: string, ...args: unknown[]): boolean;
     on(eventName: string, listener: (...args: unknown[]) => unknown): this;
@@ -74,9 +74,9 @@ export interface ExternalFileSystem {
     }): Promise<void>;
 }
 /**
- * A file file URI string or a URI object.
+ * A file URI string or a URI object.
  */
-export declare type FsLocation = string | Uri;
+export type FsLocation = string | Uri;
 export interface FsWatcher {
     on(eventName: 'ready', listener: () => unknown): this;
     once(eventName: 'ready', listener: () => unknown): this;

package/lib/common/util.d.ts

@@ -1,19 +1,15 @@
 import externalBinarySearch from 'binary-search';
+import { URL } from 'whatwg-url';
 import type { AstNode } from '../node/index.js';
 import type { ProcessorContext } from '../service/index.js';
 import type { Externals } from './externals/index.js';
-import type { DeepReadonly } from './ReadonlyProxy.js';
-export declare const Uri: {
-    new (url: string | URL, base?: string | URL | undefined): URL;
-    prototype: URL;
-    createObjectURL(obj: Blob | MediaSource): string;
-    revokeObjectURL(url: string): void;
-};
-export declare type Uri = URL;
+import type { DeepReadonly, ReadWrite } from './ReadonlyProxy.js';
+export declare const Uri: typeof URL;
+export type Uri = URL;
 /**
  * `NodeJS.Timeout` on Node.js and `number` on browser.
  */
-export declare type IntervalId = any;
+export type IntervalId = any;
 /**
  * @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 identify the `Promise`. By default the first element in the argument
@@ -35,7 +31,7 @@ export declare const Singleton: MethodDecorator;
  * 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 type FullResourceLocation = `${string}:${string}`;
+export type FullResourceLocation = `${string}:${string}`;
 export interface ResourceLocation {
     isTag: boolean;
     namespace: string | undefined;
@@ -63,7 +59,7 @@ export declare namespace ResourceLocation {
  * Byte order mark is correctly removed.
  */
 export declare function bufferToString(buffer: Uint8Array): string;
-export declare type Arrayable<T> = T | readonly T[];
+export 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[];
@@ -78,7 +74,7 @@ export declare function parseGzippedJson(externals: Externals, buffer: Uint8Arra
  */
 export declare function isPojo(value: unknown): value is Record<string, unknown>;
 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 type Lazy<T> = T | Lazy.ComplexLazy<T>;
 export declare namespace Lazy {
     const LazyDiscriminator: unique symbol;
     export type UnresolvedLazy<T> = {
@@ -116,17 +112,23 @@ export declare function emplaceMap<K, V>(map: Map<K, V>, key: K, handler: {
 export declare function isObject(val: unknown): val is object;
 export declare function normalizeUri(uri: string): string;
 /**
+ * Return a read-write TARGET type if the INPUT type is read-write, and a
+ * readonly TARGET type if the INPUT type is readonly, and `never` if the INPUT
+ * type is `undefined`.
+ *
+ * It is used in the return type of an AST node
+ * [user-defined type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
+ *
  * @example
  * ```ts
- * function isCommentNode<T extends DeepReadonly<AstNode> | undefined>(node: T): node is IsHelper<AstNode, CommentNode, T>
- * ```
- */
-export declare type IsHelper<ROOT extends object, TARGET extends ROOT, INPUT extends DeepReadonly<ROOT> | undefined> = INPUT extends DeepReadonly<ROOT> ? INPUT & DeepReadonly<TARGET> : INPUT & TARGET;
-/**
- * @example
- * ```ts
- * function isCommentNode<T extends DeepReadonly<AstNode> | undefined>(node: T): node is NodeIsHelper<CommentNode, T>
+ * export namespace CommentNode {
+ * 	export function is<T extends DeepReadonly<AstNode> | undefined>(
+ * 		obj: T,
+ * 	): obj is InheritReadonly<CommentNode, T> {
+ * 		return (obj as CommentNode | undefined)?.type === 'comment'
+ * 	}
+ * }
  * ```
  */
-export declare type NodeIsHelper<TARGET extends AstNode, INPUT extends DeepReadonly<AstNode> | undefined> = IsHelper<AstNode, TARGET, INPUT>;
+export type InheritReadonly<TARGET extends AstNode, INPUT extends DeepReadonly<AstNode> | undefined> = INPUT & (INPUT extends ReadWrite<AstNode> ? TARGET : DeepReadonly<TARGET>);
 //# sourceMappingURL=util.d.ts.map

package/lib/common/util.js

@@ -1,5 +1,16 @@
 import externalBinarySearch from 'binary-search';
 import rfdc from 'rfdc';
+import { URL } from 'whatwg-url';
+// Spyglass uses the URL class provided by the
+// [spec](https://url.spec.whatwg.org/)-compliant `whatwg-url` package instead
+// of the broken one shipped with browsers that do not parse non-special scheme
+// URLs with hosts properly.
+//
+// * [Chromium bug](https://issues.chromium.org/issues/40587286)
+// * [FireFox bug](https://bugzilla.mozilla.org/show_bug.cgi?id=1374505)
+//
+// We use the name "URI" instead of "URL" when possible, since it is what
+// LSP has chosen to use for the string that uniquely identifies a file.
 export const Uri = URL;
 /**
  * @param getKey A function that takes the actual arguments being passed into the decorated method, and returns anything.
@@ -210,7 +221,7 @@ export const binarySearch = externalBinarySearch;
 export function isIterable(value) {
     return !!value[Symbol.iterator];
 }
-//#region ESNext functions polyfill
+// #region ESNext functions polyfill
 export function atArray(array, index) {
     return index >= 0 ? array?.[index] : array?.[array.length + index];
 }
@@ -232,7 +243,7 @@ export function emplaceMap(map, key, handler) {
         throw new Error(`No key ${key} in map and no insert handler provided`);
     }
 }
-//#endregion
+// #endregion
 /**
  * @returns If `val` is an non-null object or a callable object (i.e. function).
  */

package/lib/node/AstNode.d.ts

@@ -59,7 +59,7 @@ export declare namespace AstNode {
     export function getLocalsToLeaves(node: AstNode): Generator<SymbolTable>;
     export {};
 }
-export declare type Mutable<N> = N extends AstNode ? {
+export 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

@@ -24,7 +24,9 @@ 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;

package/lib/node/CommentNode.d.ts

@@ -1,4 +1,4 @@
-import type { DeepReadonly } from '../common/index.js';
+import type { DeepReadonly, InheritReadonly } from '../common/index.js';
 import type { AstNode } from './AstNode.js';
 export interface CommentNode extends AstNode {
     readonly type: 'comment';
@@ -7,7 +7,7 @@ export interface CommentNode extends AstNode {
      */
     comment: string;
 }
-export declare const CommentNode: Readonly<{
-    is<T extends DeepReadonly<AstNode> | undefined>(obj: T): obj is import("../common/util.js").IsHelper<AstNode, CommentNode, T>;
-}>;
+export declare namespace CommentNode {
+    function is<T extends DeepReadonly<AstNode> | undefined>(obj: T): obj is InheritReadonly<CommentNode, T>;
+}
 //# sourceMappingURL=CommentNode.d.ts.map

package/lib/node/CommentNode.js

@@ -1,6 +1,8 @@
-export const CommentNode = Object.freeze({
-    is(obj) {
+export var CommentNode;
+(function (CommentNode) {
+    function is(obj) {
         return obj?.type === 'comment';
-    },
-});
+    }
+    CommentNode.is = is;
+})(CommentNode || (CommentNode = {}));
 //# sourceMappingURL=CommentNode.js.map

package/lib/node/ResourceLocationNode.d.ts

@@ -3,7 +3,7 @@ import { ResourceLocation } from '../common/index.js';
 import type { RangeLike } from '../source/index.js';
 import type { ResourceLocationCategory, SymbolAccessType, SymbolUsageType, TaggableResourceLocationCategory } from '../symbol/index.js';
 import type { AstNode } from './AstNode.js';
-export declare type ResourceLocationOptions = {
+export type ResourceLocationOptions = {
     accessType?: SymbolAccessType;
     isPredicate?: boolean;
     usageType?: SymbolUsageType;

package/lib/node/ResourceLocationNode.js

@@ -43,10 +43,9 @@ 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.
@@ -55,10 +54,9 @@ export var ResourceLocationNode;
                 break;
             case 'short':
                 // Use `node.namespace` before `&&` for the same reason stated above.
-                id =
-                    node.namespace && node.namespace !== DefaultNamespace
-                        ? `${node.namespace}${NamespacePathSep}${path}`
-                        : path;
+                id = node.namespace && node.namespace !== DefaultNamespace
+                    ? `${node.namespace}${NamespacePathSep}${path}`
+                    : path;
                 break;
         }
         return includesTagPrefix && node.isTag ? `${TagPrefix}${id}` : id;

package/lib/node/StringNode.d.ts

@@ -3,12 +3,12 @@ import type { ColorTokenType } from '../processor/index.js';
 import type { IndexMap, RangeLike } from '../source/index.js';
 import type { AstNode } from './AstNode.js';
 export declare const EscapeChars: readonly ["\"", "'", "\\", "b", "f", "n", "r", "t"];
-export declare type EscapeChar = typeof EscapeChars[number];
+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 type Quote = "'" | '"';
+export type Quote = "'" | '"';
 export interface StringOptions {
     colorTokenType?: ColorTokenType;
     escapable?: {
@@ -47,7 +47,7 @@ export interface StringOptions {
         type: AstNode['type'];
     };
 }
-export declare type QuoteTypeConfig = 'always double' | 'always single' | 'prefer double' | 'prefer single';
+export type QuoteTypeConfig = 'always double' | 'always single' | 'prefer double' | 'prefer single';
 export interface StringBaseNode extends AstNode {
     readonly options: StringOptions;
     value: string;

package/lib/node/StringNode.js

@@ -32,7 +32,10 @@ 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/parser/Parser.d.ts

@@ -4,13 +4,13 @@ import type { Source } from '../source/index.js';
 /**
  * A parser.
  */
-export declare type Parser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Result<N>;
+export type Parser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Result<N>;
 /**
  * A parser that always succeeds.
  */
-export declare type InfallibleParser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Success<N>;
-export declare type Result<T extends Returnable> = Success<T> | typeof Failure;
-export declare type Success<T extends Returnable> = T;
+export type InfallibleParser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Success<N>;
+export type Result<T extends Returnable> = Success<T> | typeof Failure;
+export type Success<T extends Returnable> = T;
 export declare const Failure: unique symbol;
-export declare type Returnable = object | string | number | bigint | boolean | undefined;
+export type Returnable = object | string | number | bigint | boolean | undefined;
 //# sourceMappingURL=Parser.d.ts.map

package/lib/parser/float.d.ts

@@ -26,7 +26,7 @@ interface InfallibleOptions extends OptionsBase {
     failsOnEmpty?: false;
 }
 /** @internal For test only */
-export declare type Options = FallibleOptions | InfallibleOptions;
+export type Options = FallibleOptions | InfallibleOptions;
 export declare function float(options: InfallibleOptions): InfallibleParser<FloatNode>;
 export declare function float(options: FallibleOptions): Parser<FloatNode>;
 export {};

package/lib/parser/integer.d.ts

@@ -26,7 +26,7 @@ interface InfallibleOptions extends OptionsBase {
     failsOnEmpty?: false;
 }
 /** @internal For test only */
-export declare type Options = FallibleOptions | InfallibleOptions;
+export type Options = FallibleOptions | InfallibleOptions;
 export declare function integer(options: InfallibleOptions): InfallibleParser<IntegerNode>;
 export declare function integer(options: FallibleOptions): Parser<IntegerNode>;
 export {};

package/lib/parser/long.d.ts

@@ -26,7 +26,7 @@ interface InfallibleOptions extends OptionsBase {
     failsOnEmpty?: false;
 }
 /** @internal For test only */
-export declare type Options = FallibleOptions | InfallibleOptions;
+export type Options = FallibleOptions | InfallibleOptions;
 export declare function long(options: InfallibleOptions): InfallibleParser<LongNode>;
 export declare function long(options: FallibleOptions): Parser<LongNode>;
 export {};

package/lib/parser/resourceLocation.js

@@ -96,7 +96,7 @@ export function resourceLocation(options) {
                 ctx.err.report(localize('parser.resource-location.illegal', arrayToMessage(illegalChars, true, 'and')), ans);
             }
             if (ans.isTag && !options.allowTag) {
-                ctx.err.report(localize('parser.resource-location.tag-diallowed'), ans);
+                ctx.err.report(localize('parser.resource-location.tag-disallowed'), ans);
             }
             if (!ans.namespace && options.isPredicate) {
                 ctx.err.report(localize('parser.resource-location.namespace-expected'), ans);