@spyglassmc/core 0.4.46 → 0.4.47

package/lib/common/Dev.d.ts

@@ -1,7 +1,7 @@
 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;
+    function assertTrue(value: unknown, message: string): asserts value;
     /**
      * @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.
      */

package/lib/common/EventDispatcher.d.ts

@@ -0,0 +1,6 @@
+export declare class EventDispatcher<TEvents extends Record<string, unknown>> {
+    #private;
+    emit<K extends keyof TEvents & string>(name: K, data: TEvents[K]): void;
+    on<K extends keyof TEvents & string>(name: K, listener: (data: TEvents[K]) => unknown, options?: AddEventListenerOptions): this;
+}
+//# sourceMappingURL=EventDispatcher.d.ts.map

package/lib/common/EventDispatcher.js

@@ -0,0 +1,15 @@
+import { Dev } from './Dev.js';
+export class EventDispatcher {
+    #target = new EventTarget();
+    emit(name, data) {
+        this.#target.dispatchEvent(new CustomEvent(name, { detail: data }));
+    }
+    on(name, listener, options) {
+        this.#target.addEventListener(name, (event) => {
+            Dev.assertTrue(event instanceof CustomEvent, 'event must be an instance of CustomEvent');
+            listener(event.detail);
+        }, options);
+        return this;
+    }
+}
+//# sourceMappingURL=EventDispatcher.js.map

package/lib/common/ReadonlyProxy.js

@@ -1,4 +1,4 @@
-import { emplaceMap, isObject } from './util.js';
+import { getOrInsertComputed, isObject } from './util.js';
 export var ReadonlyProxy;
 (function (ReadonlyProxy) {
     function create(obj) {
@@ -11,7 +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 getOrInsertComputed(this.map, p, () => ReadonlyProxy.create(value));
         }
         return value;
     }

package/lib/common/StateProxy.js

@@ -1,4 +1,4 @@
-import { emplaceMap, isObject } from '../common/index.js';
+import { getOrInsertComputed, isObject } from '../common/index.js';
 import { Operations } from './Operations.js';
 const BranchOff = Symbol('StateBranchOff');
 const Is = Symbol('IsStateProxy');
@@ -63,7 +63,7 @@ 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 getOrInsertComputed(this.map, p, () => _createStateProxy(value, this.rootOps));
         }
         return value;
     }

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

@@ -1,11 +1,3 @@
-import type { ExternalEventEmitter, Externals } from './index.js';
-type Listener = (...args: unknown[]) => unknown;
-export declare class BrowserEventEmitter implements ExternalEventEmitter {
-    #private;
-    emit(eventName: string, ...args: unknown[]): boolean;
-    on(eventName: string, listener: Listener): this;
-    once(eventName: string, listener: Listener): this;
-}
+import type { Externals } from './index.js';
 export declare const BrowserExternals: Externals;
-export {};
 //# sourceMappingURL=BrowserExternals.d.ts.map

package/lib/common/externals/BrowserExternals.js

@@ -1,40 +1,5 @@
 import { decode as arrayBufferFromBase64, encode as arrayBufferToBase64 } from 'base64-arraybuffer';
-import pako from 'pako';
 import { fileUtil } from '../../service/fileUtil.js';
-export class BrowserEventEmitter {
-    #listeners = new Map();
-    emit(eventName, ...args) {
-        const listeners = this.#listeners.get(eventName);
-        if (!listeners?.all?.size) {
-            return false;
-        }
-        for (const listener of listeners.all) {
-            listener(...args);
-            if (listeners.once.has(listener)) {
-                listeners.all.delete(listener);
-                listeners.once.delete(listener);
-            }
-        }
-        return false;
-    }
-    on(eventName, listener) {
-        if (!this.#listeners.has(eventName)) {
-            this.#listeners.set(eventName, { all: new Set(), once: new Set() });
-        }
-        const listeners = this.#listeners.get(eventName);
-        listeners.all.add(listener);
-        return this;
-    }
-    once(eventName, listener) {
-        if (!this.#listeners.has(eventName)) {
-            this.#listeners.set(eventName, { all: new Set(), once: new Set() });
-        }
-        const listeners = this.#listeners.get(eventName);
-        listeners.all.add(listener);
-        listeners.once.add(listener);
-        return this;
-    }
-}
 // TODO: Use Origin Private File System (OPFS) instead
 class BrowserFileSystem {
     static LocalStorageKey = 'spyglassmc-browser-fs';
@@ -113,21 +78,6 @@ export const BrowserExternals = {
         decompressBall(_buffer, _options) {
             throw new Error('decompressBall not supported on browser.');
         },
-        async gunzip(buffer) {
-            return pako.inflate(buffer);
-        },
-        async gzip(buffer) {
-            return pako.gzip(buffer);
-        },
-    },
-    crypto: {
-        async getSha1(data) {
-            if (typeof data === 'string') {
-                data = new TextEncoder().encode(data);
-            }
-            const hash = await crypto.subtle.digest('SHA-1', data.buffer);
-            return uint8ArrayToHex(new Uint8Array(hash));
-        },
     },
     error: {
         createKind(kind, message) {
@@ -137,19 +87,10 @@ export const BrowserExternals = {
             return e instanceof Error && e.message.startsWith(kind);
         },
     },
-    event: { EventEmitter: BrowserEventEmitter },
     fs: new BrowserFileSystem(),
     web: {
-        fetch,
         getCache: () => window.caches.open('spyglassmc'),
     },
 };
-function uint8ArrayToHex(array) {
-    let ans = '';
-    for (const v of array) {
-        ans += v.toString(16).padStart(2, '0');
-    }
-    return ans;
-}
 Object.freeze(BrowserExternals);
 //# sourceMappingURL=BrowserExternals.js.map

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

@@ -1,4 +1,3 @@
-import { EventEmitter } from 'node:events';
 import fs, { promises as fsp } from 'node:fs';
 import type { DecompressedFile, RootUriString } from '../../index.js';
 import type { FsLocation } from './index.js';
@@ -10,19 +9,11 @@ export declare function getNodeJsExternals({ cacheRoot, nodeFsp }?: {
         decompressBall(buffer: Uint8Array<ArrayBuffer>, options: {
             stripLevel?: number;
         } | undefined): Promise<DecompressedFile[]>;
-        gunzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-        gzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-    };
-    crypto: {
-        getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
     };
     error: {
         createKind(kind: import("./index.js").ExternalErrorKind, message: string): Error;
         isKind(e: unknown, kind: import("./index.js").ExternalErrorKind): boolean;
     };
-    event: {
-        EventEmitter: typeof EventEmitter;
-    };
     fs: {
         chmod(location: FsLocation, mode: number): Promise<void>;
         mkdir(location: FsLocation, options: {
@@ -42,7 +33,6 @@ export declare function getNodeJsExternals({ cacheRoot, nodeFsp }?: {
         } | undefined): Promise<void>;
     };
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<HttpCache>;
     };
 }>;
@@ -51,19 +41,11 @@ export declare const NodeJsExternals: Readonly<{
         decompressBall(buffer: Uint8Array<ArrayBuffer>, options: {
             stripLevel?: number;
         } | undefined): Promise<DecompressedFile[]>;
-        gunzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-        gzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-    };
-    crypto: {
-        getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
     };
     error: {
         createKind(kind: import("./index.js").ExternalErrorKind, message: string): Error;
         isKind(e: unknown, kind: import("./index.js").ExternalErrorKind): boolean;
     };
-    event: {
-        EventEmitter: typeof EventEmitter;
-    };
     fs: {
         chmod(location: FsLocation, mode: number): Promise<void>;
         mkdir(location: FsLocation, options: {
@@ -83,7 +65,6 @@ export declare const NodeJsExternals: Readonly<{
         } | undefined): Promise<void>;
     };
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<HttpCache>;
     };
 }>;

package/lib/common/externals/NodeJsExternals.js

@@ -1,17 +1,12 @@
 import decompress from 'decompress';
 import { Buffer } from 'node:buffer';
 import cp from 'node:child_process';
-import crypto from 'node:crypto';
-import { EventEmitter } from 'node:events';
 import fs, { promises as fsp } from 'node:fs';
 import os from 'node:os';
 import process from 'node:process';
 import stream from 'node:stream';
 import url from 'node:url';
 import { promisify } from 'node:util';
-import zlib from 'node:zlib';
-const gunzip = promisify(zlib.gunzip);
-const gzip = promisify(zlib.gzip);
 export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
     return Object.freeze({
         archive: {
@@ -21,19 +16,6 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
                 }
                 return decompress(buffer, { strip: options?.stripLevel });
             },
-            gunzip(buffer) {
-                return gunzip(buffer);
-            },
-            gzip(buffer) {
-                return gzip(buffer);
-            },
-        },
-        crypto: {
-            async getSha1(data) {
-                const hash = crypto.createHash('sha1');
-                hash.update(data);
-                return hash.digest('hex');
-            },
         },
         error: {
             createKind(kind, message) {
@@ -45,7 +27,6 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
                 return e instanceof Error && e.code === kind;
             },
         },
-        event: { EventEmitter },
         fs: {
             chmod(location, mode) {
                 return nodeFsp.chmod(toFsPathLike(location), mode);
@@ -92,7 +73,6 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
             },
         },
         web: {
-            fetch,
             getCache: async () => {
                 return new HttpCache(cacheRoot);
             },

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

@@ -4,14 +4,6 @@ export interface Externals {
         decompressBall: (buffer: Uint8Array<ArrayBuffer>, options?: {
             stripLevel?: number;
         }) => Promise<DecompressedFile[]>;
-        gzip: (buffer: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>;
-        gunzip: (buffer: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>;
-    };
-    crypto: {
-        /**
-         * @returns SHA-1 digest of the given data in hexadecimal format.
-         */
-        getSha1: (data: string | Uint8Array<ArrayBuffer>) => Promise<string>;
     };
     error: {
         /**
@@ -23,12 +15,8 @@ export interface Externals {
          */
         isKind: (e: unknown, kind: ExternalErrorKind) => boolean;
     };
-    event: {
-        EventEmitter: new () => ExternalEventEmitter;
-    };
     fs: ExternalFileSystem;
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<Cache>;
     };
 }
@@ -40,11 +28,6 @@ export interface DecompressedFile {
     type: string;
 }
 export type ExternalErrorKind = 'EEXIST' | 'EISDIR' | 'ENOENT';
-export interface ExternalEventEmitter {
-    emit(eventName: string, ...args: unknown[]): boolean;
-    on(eventName: string, listener: (...args: unknown[]) => unknown): this;
-    once(eventName: string, listener: (...args: unknown[]) => unknown): this;
-}
 export interface ExternalFileSystem {
     /**
      * @param mode File mode bit mask (e.g. `0o775`).

package/lib/common/index.d.ts

@@ -1,4 +1,5 @@
 export * from './Dev.js';
+export * from './EventDispatcher.js';
 export * from './externals/index.js';
 export * from './json.js';
 export * from './Logger.js';

package/lib/common/index.js

@@ -1,4 +1,5 @@
 export * from './Dev.js';
+export * from './EventDispatcher.js';
 export * from './externals/index.js';
 export * from './json.js';
 export * from './Logger.js';

package/lib/common/util.d.ts

@@ -1,7 +1,6 @@
 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, ReadWrite } from './ReadonlyProxy.js';
 export declare const Uri: {
     new (url: string | URL, base?: string | URL): URL;
@@ -77,7 +76,7 @@ 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 function parseGzippedJson(externals: Externals, buffer: Uint8Array<ArrayBuffer>): Promise<unknown>;
+export declare function parseGzippedJson(bytes: Uint8Array<ArrayBuffer>): Promise<unknown>;
 /**
  * @returns Is Plain Old JavaScript Object (POJO).
  */
@@ -110,17 +109,25 @@ 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;
+export declare function getOrInsert<K, V>(map: Map<K, V>, key: K, defaultValue: V): V;
+export declare function getOrInsertComputed<K, V>(map: Map<K, V>, key: K, callbackFunction: (key: K) => V): V;
+/**
+ * TODO: replace with ESNext Uint8Array.prototype.toHex once it's widely supported
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
 /**
  * @returns If `val` is an non-null object or a callable object (i.e. function).
  */
 export declare function isObject(val: unknown): val is object;
 export declare function normalizeUriPathname(pathname: string): string;
 export declare function normalizeUri(uri: string): string;
+export declare function getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
+export declare function compressBytes(bytes: Uint8Array<ArrayBuffer>, algorithm: CompressionFormat): Promise<Uint8Array<ArrayBuffer>>;
+export declare function compressStream(stream: ReadableStream<Uint8Array<ArrayBuffer>>, algorithm: CompressionFormat): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function decompressBytes(bytes: Uint8Array<ArrayBuffer>, algorithm: CompressionFormat): Promise<Uint8Array<ArrayBuffer>>;
+export declare function decompressStream(stream: ReadableStream<Uint8Array<ArrayBuffer>>, algorithm: CompressionFormat): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function bytesToStream(bytes: Uint8Array<ArrayBuffer>): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function streamToBytes(stream: ReadableStream<Uint8Array<ArrayBuffer>>): Promise<Uint8Array<ArrayBuffer>>;
 /**
  * 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

package/lib/common/util.js

@@ -146,8 +146,8 @@ export function promisifyAsyncIterable(iterable, joiner) {
         return joiner(chunks);
     })();
 }
-export async function parseGzippedJson(externals, buffer) {
-    return JSON.parse(bufferToString(await externals.archive.gunzip(buffer)));
+export async function parseGzippedJson(bytes) {
+    return JSON.parse(bufferToString(await decompressBytes(bytes, 'gzip')));
 }
 /**
  * @returns Is Plain Old JavaScript Object (POJO).
@@ -218,26 +218,33 @@ 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 getOrInsert(map, key, defaultValue) {
+    if (!map.has(key)) {
+        map.set(key, defaultValue);
+    }
+    return map.get(key);
 }
-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;
+export function getOrInsertComputed(map, key, callbackFunction) {
+    if (!map.has(key)) {
+        map.set(key, callbackFunction(key));
+    }
+    return map.get(key);
+}
+/**
+ * TODO: replace with ESNext Uint8Array.prototype.toHex once it's widely supported
+ */
+export function bytesToHex(bytes) {
+    if ('Buffer' in globalThis && bytes instanceof Buffer) {
+        return bytes.toString('hex');
     }
-    else if (handler.insert) {
-        const value = handler.insert(key, map);
-        map.set(key, value);
-        return value;
+    else if ('toHex' in Uint8Array.prototype && typeof Uint8Array.prototype.toHex === 'function') {
+        return Uint8Array.prototype.toHex.call(bytes);
     }
-    else {
-        throw new Error(`No key ${key} in map and no insert handler provided`);
+    let ans = '';
+    for (const v of bytes) {
+        ans += v.toString(16).padStart(2, '0');
     }
+    return ans;
 }
 // #endregion
 /**
@@ -267,6 +274,31 @@ export function normalizeUri(uri) {
     obj.pathname = normalizeUriPathname(obj.pathname);
     return obj.toString();
 }
+export async function getSha1(data) {
+    if (typeof data === 'string') {
+        data = new TextEncoder().encode(data);
+    }
+    const hash = await crypto.subtle.digest('SHA-1', data.buffer);
+    return bytesToHex(new Uint8Array(hash));
+}
+export function compressBytes(bytes, algorithm) {
+    return streamToBytes(compressStream(bytesToStream(bytes), algorithm));
+}
+export function compressStream(stream, algorithm) {
+    return stream.pipeThrough(new CompressionStream(algorithm));
+}
+export function decompressBytes(bytes, algorithm) {
+    return streamToBytes(decompressStream(bytesToStream(bytes), algorithm));
+}
+export function decompressStream(stream, algorithm) {
+    return stream.pipeThrough(new DecompressionStream(algorithm));
+}
+export function bytesToStream(bytes) {
+    return new Blob([bytes]).stream();
+}
+export function streamToBytes(stream) {
+    return new Response(stream).bytes();
+}
 /**
  * Checks if the numeric value of a number or bigint is the same. Undefined is **not** the same as
  * 0 for this function.

package/lib/node/StringNode.d.ts

@@ -2,7 +2,7 @@ import type { Parser } from '../parser/index.js';
 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", "s", "t"];
+export declare const EscapeChars: readonly ['"', "'", '\\', 'b', 'f', 'n', 'r', 's', 't'];
 export type EscapeChar = (typeof EscapeChars)[number];
 export declare namespace EscapeChar {
     function is(expected: EscapeChar[] | undefined, c: string): c is EscapeChar;

package/lib/parser/string.d.ts

@@ -6,11 +6,11 @@ import type { Parser, Result, Returnable } from './Parser.js';
 export declare function string(options: StringOptions): InfallibleParser<StringNode>;
 export declare function parseStringValue<T extends Returnable>(parser: Parser<T>, value: string, map: IndexMap, ctx: ParserContext): Result<T>;
 export declare const BrigadierUnquotableCharacters: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "_", ".", "+", "-"];
-export declare const BrigadierUnquotableCharacterSet: Set<"0" | "k" | "v" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "e" | "E" | "i" | "p" | "-" | "+" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "w" | "x" | "y" | "z" | "_" | "A" | "B" | "C" | "D" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
+export declare const BrigadierUnquotableCharacterSet: Set<"+" | "-" | "." | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z">;
 export declare const BrigadierUnquotablePattern: RegExp;
 export declare const BrigadierUnquotableOption: {
     allowEmpty: boolean;
-    allowList: Set<"0" | "k" | "v" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "e" | "E" | "i" | "p" | "-" | "+" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "w" | "x" | "y" | "z" | "_" | "A" | "B" | "C" | "D" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
+    allowList: Set<"+" | "-" | "." | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z">;
 };
 export declare const BrigadierStringOptions: StringOptions;
 export declare const brigadierString: InfallibleParser<StringNode>;

package/lib/processor/colorizer/Colorizer.d.ts

@@ -18,7 +18,7 @@ export declare namespace ColorToken {
     function fillGap(tokens: readonly ColorToken[], targetRange: Range, type: ColorTokenType, modifiers?: ColorTokenModifier[]): ColorToken[];
 }
 export declare const ColorTokenTypes: readonly ["comment", "enum", "enumMember", "escape", "function", "keyword", "modifier", "number", "property", "string", "struct", "type", "variable", "error", "literal", "operator", "resourceLocation", "vector"];
-export type ColorTokenType = typeof ColorTokenTypes[number];
+export type ColorTokenType = (typeof ColorTokenTypes)[number];
 export declare const ColorTokenModifiers: readonly ["declaration", "defaultLibrary", "definition", "deprecated", "documentation", "modification", "readonly"];
-export type ColorTokenModifier = typeof ColorTokenModifiers[number];
+export type ColorTokenModifier = (typeof ColorTokenModifiers)[number];
 //# sourceMappingURL=Colorizer.d.ts.map

package/lib/service/CacheService.js

@@ -1,4 +1,4 @@
-import { bigintJsonLosslessReplacer, bigintJsonLosslessReviver, Uri } from '../common/index.js';
+import { bigintJsonLosslessReplacer, bigintJsonLosslessReviver, getSha1, Uri, } from '../common/index.js';
 import { SymbolTable } from '../symbol/index.js';
 import { ArchiveUriSupporter } from './FileService.js';
 import { fileUtil } from './fileUtil.js';
@@ -36,7 +36,7 @@ export class CacheService {
             }
             try {
                 // TODO: Don't update this for every single change.
-                this.checksums.files[doc.uri] = await this.project.externals.crypto.getSha1(doc.getText());
+                this.checksums.files[doc.uri] = await getSha1(doc.getText());
             }
             catch (e) {
                 if (!this.project.externals.error.isKind(e, 'EISDIR')) {
@@ -72,7 +72,7 @@ export class CacheService {
     async getCacheFileUri() {
         if (!this.#cacheFilePath) {
             const sortedRoots = [...this.project.projectRoots].sort();
-            const hash = await this.project.externals.crypto.getSha1(sortedRoots.join(':'));
+            const hash = await getSha1(sortedRoots.join(':'));
             this.#cacheFilePath = new Uri(`symbols/${hash}.json.gz`, this.cacheRoot).toString();
         }
         return this.#cacheFilePath;
@@ -196,8 +196,7 @@ export class CacheService {
         return false;
     }
     async hasFileChangedSinceCache(doc) {
-        return (this.checksums.files[doc.uri]
-            !== (await this.project.externals.crypto.getSha1(doc.getText())));
+        return (this.checksums.files[doc.uri] !== (await getSha1(doc.getText())));
     }
     reset() {
         this.#hasValidatedFiles = false;

package/lib/service/Config.d.ts

@@ -1,5 +1,5 @@
-import type { DeepPartial, ExternalEventEmitter } from '../common/index.js';
-import { Arrayable } from '../common/index.js';
+import type { DeepPartial } from '../common/index.js';
+import { Arrayable, EventDispatcher } from '../common/index.js';
 import { ErrorSeverity } from '../source/index.js';
 import type { Project } from './Project.js';
 export interface Config {
@@ -239,19 +239,15 @@ type ErrorEvent = {
     error: unknown;
     uri: string;
 };
-export declare class ConfigService implements ExternalEventEmitter {
-    #private;
+export declare class ConfigService extends EventDispatcher<{
+    changed: ConfigEvent;
+    error: ErrorEvent;
+}> {
     private readonly project;
     private readonly defaultConfig;
     static readonly ConfigFileNames: readonly ["spyglass.json", ".spyglassrc", ".spyglassrc.json"];
     private currentEditorConfiguration;
     constructor(project: Project, defaultConfig?: Config);
-    on(event: 'changed', callbackFn: (data: ConfigEvent) => void): this;
-    on(event: 'error', callbackFn: (data: ErrorEvent) => void): this;
-    once(event: 'changed', callbackFn: (data: ConfigEvent) => void): this;
-    once(event: 'error', callbackFn: (data: ErrorEvent) => void): this;
-    emit(event: 'changed', data: ConfigEvent): boolean;
-    emit(event: 'error', data: ErrorEvent): boolean;
     onEditorConfigurationUpdate(editorConfiguration: PartialConfig): Promise<void>;
     load(): Promise<Config>;
     static isConfigFile(this: void, uri: string): boolean;

package/lib/service/Config.js

@@ -1,5 +1,5 @@
 import rfdc from 'rfdc';
-import { Arrayable, bufferToString, merge, TypePredicates } from '../common/index.js';
+import { Arrayable, bufferToString, EventDispatcher, merge, TypePredicates, } from '../common/index.js';
 import { ErrorSeverity } from '../source/index.js';
 import { DataFileCategories, RegistryCategories } from '../symbol/index.js';
 export var LinterSeverity;
@@ -296,16 +296,15 @@ export var PartialConfig;
     }
     PartialConfig.buildConfigFromEditorSettingsSafe = buildConfigFromEditorSettingsSafe;
 })(PartialConfig || (PartialConfig = {}));
-export class ConfigService {
+export class ConfigService extends EventDispatcher {
     project;
     defaultConfig;
     static ConfigFileNames = Object.freeze(['spyglass.json', '.spyglassrc', '.spyglassrc.json']);
-    #eventEmitter;
     currentEditorConfiguration = {};
     constructor(project, defaultConfig = VanillaConfig) {
+        super();
         this.project = project;
         this.defaultConfig = defaultConfig;
-        this.#eventEmitter = new project.externals.event.EventEmitter();
         const handler = async ({ uri }) => {
             if (ConfigService.isConfigFile(uri)) {
                 this.emit('changed', { config: await this.load() });
@@ -315,17 +314,6 @@ export class ConfigService {
         project.on('fileModified', handler);
         project.on('fileDeleted', handler);
     }
-    on(event, callbackFn) {
-        this.#eventEmitter.on(event, callbackFn);
-        return this;
-    }
-    once(event, callbackFn) {
-        this.#eventEmitter.once(event, callbackFn);
-        return this;
-    }
-    emit(event, ...args) {
-        return this.#eventEmitter.emit(event, ...args);
-    }
     async onEditorConfigurationUpdate(editorConfiguration) {
         this.currentEditorConfiguration = editorConfiguration;
         this.emit('changed', { config: await this.load() });