@spyglassmc/core 0.2.0 → 0.3.0

package/lib/common/Dev.d.ts

@@ -0,0 +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;
+    /**
+     * @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;
+}>;
+//# sourceMappingURL=Dev.d.ts.map

package/lib/common/Dev.js

@@ -0,0 +1,90 @@
+export const Dev = Object.freeze({
+    assertDefined(value) {
+        if (value === undefined) {
+            throw new Error(`'${Dev.stringify(value)}' is 'undefined'`);
+        }
+    },
+    assertNever(value) {
+        throw new Error(`'${Dev.stringify(value)}' is not of type 'never'`);
+    },
+    assertTrue(value, message) {
+        if (!value) {
+            throw new Error(`Assertion failed: ${message}. '${Dev.stringify(value)}' should be true.`);
+        }
+    },
+    /**
+     * @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) {
+        const ByteToBits = 8;
+        const PointerSize = 8;
+        let ans = 0;
+        const calculatedObjects = new Set();
+        const stack = [value];
+        while (stack.length) {
+            const current = stack.pop();
+            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
+                    break;
+                }
+                case 'boolean':
+                    ans += PointerSize; // Aggressive alignment estimation.
+                    break;
+                case 'number':
+                    ans += 8;
+                    break;
+                case 'object':
+                    ans += PointerSize; // Reference pointer.
+                    if (!current || calculatedObjects.has(current)) {
+                        break;
+                    }
+                    ans += PointerSize; // Header pointer.
+                    for (const value of Object.values(current)) {
+                        stack.push(value);
+                        ans += PointerSize; // Aggressive padding estimation.
+                    }
+                    calculatedObjects.add(current);
+                    break;
+                case 'string':
+                    ans += current.length * 2;
+                    break;
+                case 'symbol':
+                    ans += PointerSize;
+                    break;
+                default:
+                    break;
+            }
+        }
+        return ans;
+    },
+    stringify(value) {
+        if (value && typeof value === 'object') {
+            try {
+                const seen = new Set();
+                return JSON.stringify(value, (_k, v) => {
+                    if (v && typeof v === 'object') {
+                        return seen.has(v) ? '[Circular]' : (seen.add(v), v);
+                    }
+                    else {
+                        return v;
+                    }
+                });
+            }
+            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(', ')} }`;
+            }
+        }
+        else if (typeof value === 'symbol') {
+            // JavaScript does not convert `Symbol`s to strings implicitly.
+            return String(value);
+        }
+        else {
+            return `${value}`;
+        }
+    },
+});
+//# sourceMappingURL=Dev.js.map

package/lib/common/Operations.d.ts

@@ -0,0 +1,12 @@
+export declare class Operations {
+    private readonly parent?;
+    constructor(parent?: Operations | undefined);
+    private readonly undoOps;
+    private readonly redoOps;
+    private addUndoOp;
+    private addRedoOp;
+    set<O extends object, K extends keyof O>(obj: O, key: K, value: O[K], receiver?: any): void;
+    undo(): void;
+    redo(): void;
+}
+//# sourceMappingURL=Operations.d.ts.map

package/lib/common/Operations.js

@@ -0,0 +1,33 @@
+export class Operations {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    undoOps = [];
+    redoOps = [];
+    addUndoOp(op) {
+        this.undoOps.push(op);
+        this.parent?.addUndoOp(op);
+    }
+    addRedoOp(op) {
+        this.redoOps.push(op);
+        this.parent?.addRedoOp(op);
+    }
+    set(obj, key, value, receiver = obj) {
+        const oldValue = Reflect.get(obj, key, receiver);
+        const op = () => { Reflect.set(obj, key, value, receiver); };
+        const undoOp = () => { Reflect.set(obj, key, oldValue, receiver); };
+        this.addRedoOp(op);
+        this.addUndoOp(undoOp);
+        op();
+    }
+    undo() {
+        for (let i = this.undoOps.length - 1; i >= 0; i--) {
+            this.undoOps[i]();
+        }
+    }
+    redo() {
+        this.redoOps.forEach(op => op());
+    }
+}
+//# sourceMappingURL=Operations.js.map

package/lib/common/ReadonlyProxy.d.ts

@@ -0,0 +1,9 @@
+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]>;
+};
+export declare const ReadonlyProxy: Readonly<{
+    create<T extends object>(obj: T): DeepReadonly<T>;
+}>;
+export {};
+//# sourceMappingURL=ReadonlyProxy.d.ts.map

package/lib/common/ReadonlyProxy.js

@@ -0,0 +1,23 @@
+import { emplaceMap, isObject } from './util.js';
+export const ReadonlyProxy = Object.freeze({
+    create(obj) {
+        return new Proxy(obj, new ReadonlyProxyHandler());
+    },
+});
+class ReadonlyProxyHandler {
+    map = new Map();
+    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 value;
+    }
+    set(_target, p, _value, _receiver) {
+        throw new TypeError(`Cannot set property '${String(p)}' on a readonly proxy`);
+    }
+    deleteProperty(_target, p) {
+        throw new TypeError(`Cannot delete property '${String(p)}' on a readonly proxy`);
+    }
+}
+//# sourceMappingURL=ReadonlyProxy.js.map

package/lib/common/StateProxy.d.ts

@@ -0,0 +1,35 @@
+declare const BranchOff: unique symbol;
+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;
+/**
+ * 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
+ * proxy was created using {@link StateProxy.redoChanges} and {@link StateProxy.undoChanges}.
+ *
+ * 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> = {
+    [K in keyof T]: Wrap<T[K]>;
+} & {
+    [BranchOff]: () => StateProxy<T>;
+    [Is]: true;
+    [Origin]: T;
+    [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 & {
+        _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;
+}>;
+export {};
+//# sourceMappingURL=StateProxy.d.ts.map

package/lib/common/StateProxy.js

@@ -0,0 +1,69 @@
+import { emplaceMap, isObject } from '../common/index.js';
+import { Operations } from './Operations.js';
+const BranchOff = Symbol('StateBranchOff');
+const Is = Symbol('IsStateProxy');
+const Origin = Symbol('OriginState');
+const Redo = Symbol('RedoStateChanges');
+const Undo = Symbol('UndoStateChanges');
+export const StateProxy = Object.freeze({
+    branchOff(proxy) {
+        return proxy[BranchOff]();
+    },
+    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) {
+        return StateProxy.is(value) ? value[Origin] : value;
+    },
+    is(obj) {
+        return obj?.[Is];
+    },
+    redoChanges(proxy) {
+        proxy[Redo]();
+    },
+    undoChanges(proxy) {
+        proxy[Undo]();
+    },
+});
+class StateProxyHandler {
+    rootOps;
+    map = new Map();
+    constructor(
+    /**
+     * Shared across all handlers created for the same root state object under the same branch.
+     */
+    rootOps) {
+        this.rootOps = rootOps;
+    }
+    #branchOff(target) {
+        return _createStateProxy(target, new Operations(this.rootOps));
+    }
+    get(target, p, receiver) {
+        switch (p) {
+            case BranchOff: return () => this.#branchOff(target);
+            case Is: return true;
+            case Origin: return target;
+            case Redo: return () => this.rootOps.redo();
+            case Undo: return () => this.rootOps.undo();
+        }
+        const value = Reflect.get(target, p, receiver);
+        if (p !== 'prototype' && isObject(value)) {
+            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) {
+            throw new TypeError(`Cannot set ${String(p)}`);
+        }
+        this.rootOps.set(target, p, StateProxy.dereference(value), receiver);
+        return true;
+    }
+}
+function _createStateProxy(target, operations) {
+    return new Proxy(target, new StateProxyHandler(operations));
+}
+//# sourceMappingURL=StateProxy.js.map

package/lib/common/externals/NodeJsExternals.js

@@ -1,3 +1,4 @@
+// https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/60592
 import chokidar from 'chokidar';
 import decompress from 'decompress';
 import followRedirects from 'follow-redirects';

package/lib/common/index.d.ts

@@ -1,3 +1,9 @@
+export * from './Dev.js';
 export * from './externals/index.js';
+export * from './Logger.js';
+export * from './Operations.js';
+export * from './ReadonlyProxy.js';
+export * from './StateProxy.js';
+export * from './TwoWayMap.js';
 export * from './util.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/common/index.js

@@ -1,3 +1,9 @@
+export * from './Dev.js';
 export * from './externals/index.js';
+export * from './Logger.js';
+export * from './Operations.js';
+export * from './ReadonlyProxy.js';
+export * from './StateProxy.js';
+export * from './TwoWayMap.js';
 export * from './util.js';
 //# sourceMappingURL=index.js.map

package/lib/common/util.d.ts

@@ -1,6 +1,8 @@
 import externalBinarySearch from 'binary-search';
+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;
@@ -13,14 +15,14 @@ export declare type Uri = URL;
  */
 export declare type IntervalId = any;
 /**
- * @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
+ * @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
  * 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.
+ * the same key, provided that the previously returned `Promise` is still pending.
  */
-export declare function CachePromise(getCacheKey?: (args: any[]) => any): MethodDecorator;
+export declare function SingletonPromise(getKey?: (args: any[]) => any): MethodDecorator;
 /**
  * This is a decorator for methods. Decorated methods will return the same non-`undefined` value no matter what.
  */
@@ -71,7 +73,10 @@ export declare namespace TypePredicates {
 }
 export declare function promisifyAsyncIterable<T, U>(iterable: AsyncIterable<T>, joiner: (chunks: T[]) => U): Promise<U>;
 export declare function parseGzippedJson(externals: Externals, buffer: Uint8Array): Promise<unknown>;
-export declare function isObject(value: unknown): value is Exclude<object, Array<any>>;
+/**
+ * @returns Is Plain Old JavaScript Object (POJO).
+ */
+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 declare namespace Lazy {
@@ -100,4 +105,27 @@ export declare namespace Lazy {
 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>;
+export declare function atArray<T>(array: readonly T[] | undefined, index: number): T | undefined;
+export declare function emplaceMap<K, V>(map: Map<K, V>, key: K, handler: {
+    insert?: (key: K, map: Map<K, V>) => V;
+    update?: (existing: V, key: K, map: Map<K, V>) => V;
+}): V;
+/**
+ * @returns If `val` is an non-null object or a callable object (i.e. function).
+ */
+export declare function isObject(val: unknown): val is object;
+/**
+ * @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 declare type NodeIsHelper<TARGET extends AstNode, INPUT extends DeepReadonly<AstNode> | undefined> = IsHelper<AstNode, TARGET, INPUT>;
 //# sourceMappingURL=util.d.ts.map

package/lib/common/util.js

@@ -2,26 +2,26 @@ import externalBinarySearch from 'binary-search';
 import rfdc from 'rfdc';
 export const Uri = 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
+ * @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
  * 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.
+ * the same key, provided that the previously returned `Promise` is still pending.
  */
-export function CachePromise(getCacheKey = args => args[0]) {
+export function SingletonPromise(getKey = 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 key = getKey(args);
+            if (promises.has(key)) {
+                return promises.get(key);
             }
             const ans = decoratedMethod.apply(this, args)
-                .then(ans => (promises.delete(cacheKey), ans), e => (promises.delete(cacheKey), Promise.reject(e)));
-            promises.set(cacheKey, ans);
+                .then(ans => (promises.delete(key), ans), e => (promises.delete(key), Promise.reject(e)));
+            promises.set(key, ans);
             return ans;
         };
         return descripter;
@@ -138,13 +138,16 @@ export function promisifyAsyncIterable(iterable, joiner) {
 export async function parseGzippedJson(externals, buffer) {
     return JSON.parse(bufferToString(await externals.archive.gunzip(buffer)));
 }
-export function isObject(value) {
+/**
+ * @returns Is Plain Old JavaScript Object (POJO).
+ */
+export function isPojo(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 export function merge(a, b) {
     const ans = rfdc()(a);
     for (const [key, value] of Object.entries(b)) {
-        if (isObject(ans[key]) && isObject(value)) {
+        if (isPojo(ans[key]) && isPojo(value)) {
             ans[key] = merge(ans[key], value);
         }
         else if (value === undefined) {
@@ -208,4 +211,33 @@ export const binarySearch = externalBinarySearch;
 export function isIterable(value) {
     return !!value[Symbol.iterator];
 }
+//#region ESNext functions polyfill
+export function atArray(array, index) {
+    return index >= 0 ? array?.[index] : array?.[array.length + index];
+}
+export function emplaceMap(map, key, handler) {
+    if (map.has(key)) {
+        let value = map.get(key);
+        if (handler.update) {
+            value = handler.update(value, key, map);
+            map.set(key, value);
+        }
+        return value;
+    }
+    else if (handler.insert) {
+        const value = handler.insert(key, map);
+        map.set(key, value);
+        return value;
+    }
+    else {
+        throw new Error(`No key ${key} in map and no insert handler provided`);
+    }
+}
+//#endregion
+/**
+ * @returns If `val` is an non-null object or a callable object (i.e. function).
+ */
+export function isObject(val) {
+    return typeof val === 'function' || (!!val && typeof val === 'object');
+}
 //# sourceMappingURL=util.js.map

package/lib/node/AstNode.d.ts

@@ -1,14 +1,15 @@
+import type { DeepReadonly } from '../common/index.js';
 import type { Color, FormattableColor } from '../processor/index.js';
 import { Range } from '../source/index.js';
 import type { Symbol, SymbolTable } from '../symbol/index.js';
 export interface AstNode {
-    readonly type: string;
-    readonly range: Range;
+    type: string;
+    range: Range;
     /**
      * All child nodes of this AST node.
      */
-    readonly children?: AstNode[];
-    readonly parent?: AstNode;
+    children?: AstNode[];
+    parent?: AstNode;
     locals?: SymbolTable;
     symbol?: Symbol;
     hover?: string;
@@ -23,21 +24,21 @@ export declare namespace AstNode {
     /**
      * @param endInclusive Defaults to `false`.
      */
-    export function findChildIndex(node: AstNode, needle: number | Range, endInclusive?: boolean): number;
+    export function findChildIndex(node: DeepReadonly<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;
+    export function findChild<N extends DeepReadonly<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;
+    export function findLastChildIndex(node: DeepReadonly<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;
+    export function findLastChild<N extends DeepReadonly<AstNode>>(node: N, needle: number | Range, endInclusive?: boolean): (N['children'] extends readonly unknown[] ? N['children'][number] : undefined) | undefined;
     interface FindRecursivelyOptions<P = (node: AstNode) => boolean> {
         node: AstNode;
         needle: number;

package/lib/node/CommentNode.d.ts

@@ -1,12 +1,13 @@
+import type { DeepReadonly } from '../common/index.js';
 import type { AstNode } from './AstNode.js';
 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;
+    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>;
+}>;
 //# sourceMappingURL=CommentNode.d.ts.map

package/lib/node/CommentNode.js

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

package/lib/node/FileNode.d.ts

@@ -5,7 +5,11 @@ export interface FileNode<CN extends AstNode> extends AstNode {
     readonly type: 'file';
     readonly children: CN[];
     locals: SymbolTable;
-    readonly parserErrors: readonly LanguageError[];
+    parserErrors: readonly LanguageError[];
+    /**
+     * Only exists when the file has been bound.
+     */
+    binderErrors?: readonly LanguageError[];
     /**
      * Only exists when the file has been checked.
      */

package/lib/node/FileNode.js

@@ -1,7 +1,7 @@
 export var FileNode;
 (function (FileNode) {
     function getErrors(node) {
-        return [...node.parserErrors, ...node.checkerErrors ?? [], ...node.linterErrors ?? []];
+        return [...node.parserErrors, ...node.binderErrors ?? [], ...node.checkerErrors ?? [], ...node.linterErrors ?? []];
     }
     FileNode.getErrors = getErrors;
 })(FileNode || (FileNode = {}));

package/lib/node/FloatNode.d.ts

@@ -1,7 +1,7 @@
 import type { RangeLike } from '../source/index.js';
 import type { AstNode } from './AstNode.js';
 export interface FloatBaseNode extends AstNode {
-    readonly value: number;
+    value: number;
 }
 export interface FloatNode extends FloatBaseNode {
     readonly type: 'float';

package/lib/node/IntegerNode.d.ts

@@ -1,7 +1,7 @@
 import type { RangeLike } from '../source/index.js';
 import type { AstNode } from './AstNode.js';
 export interface IntegerBaseNode extends AstNode {
-    readonly value: number;
+    value: number;
 }
 export interface IntegerNode extends IntegerBaseNode {
     readonly type: 'integer';

package/lib/node/LiteralNode.d.ts

@@ -7,7 +7,7 @@ export interface LiteralOptions {
 }
 export interface LiteralBaseNode extends AstNode {
     readonly options: LiteralOptions;
-    readonly value: string;
+    value: string;
 }
 export interface LiteralNode extends LiteralBaseNode {
     readonly type: 'literal';

package/lib/node/LongNode.d.ts

@@ -1,7 +1,7 @@
 import type { RangeLike } from '../source/index.js';
 import type { AstNode } from './AstNode.js';
 export interface LongBaseNode extends AstNode {
-    readonly value: bigint;
+    value: bigint;
 }
 export interface LongNode extends LongBaseNode {
     readonly type: 'long';

package/lib/node/ResourceLocationNode.d.ts

@@ -1,4 +1,4 @@
-import type { FullResourceLocation } from '../common/index.js';
+import type { DeepReadonly, FullResourceLocation } from '../common/index.js';
 import { ResourceLocation } from '../common/index.js';
 import type { RangeLike } from '../source/index.js';
 import type { ResourceLocationCategory, SymbolAccessType, SymbolUsageType, TaggableResourceLocationCategory } from '../symbol/index.js';
@@ -33,7 +33,7 @@ export interface ResourceLocationNode extends ResourceLocationBaseNode {
 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;
+    function toString(node: DeepReadonly<ResourceLocationBaseNode>, type?: 'full'): FullResourceLocation;
+    function toString(node: DeepReadonly<ResourceLocationBaseNode>, type?: 'origin' | 'full' | 'short'): string;
 }
 //# sourceMappingURL=ResourceLocationNode.d.ts.map

package/lib/node/StringNode.d.ts

@@ -50,7 +50,7 @@ export interface StringOptions {
 export declare type QuoteTypeConfig = 'always double' | 'always single' | 'prefer double' | 'prefer single';
 export interface StringBaseNode extends AstNode {
     readonly options: StringOptions;
-    readonly value: string;
+    value: string;
     readonly valueMap: IndexMap;
 }
 export interface StringNode extends StringBaseNode {