@spyglassmc/core 0.2.0 → 0.3.0

package/lib/service/Project.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { bufferToString, CachePromise } from '../common/index.js';
+import { bufferToString, Logger, SingletonPromise, StateProxy } from '../common/index.js';
 import { FileNode } from '../node/index.js';
 import { file } from '../parser/index.js';
 import { traversePreOrder } from '../processor/index.js';
@@ -13,30 +13,64 @@ import { Source } from '../source/index.js';
 import { SymbolUtil } from '../symbol/index.js';
 import { CacheService } from './CacheService.js';
 import { ConfigService, LinterConfigValue } from './Config.js';
-import { CheckerContext, LinterContext, ParserContext, UriBinderContext } from './Context.js';
+import { BinderContext, CheckerContext, LinterContext, ParserContext, UriBinderContext } from './Context.js';
 import { DependencyKey } from './Dependency.js';
 import { Downloader } from './Downloader.js';
 import { LinterErrorReporter } from './ErrorReporter.js';
 import { ArchiveUriSupporter, FileService, FileUriSupporter } from './FileService.js';
 import { fileUtil } from './fileUtil.js';
-import { Logger } from './Logger.js';
 import { MetaRegistry } from './MetaRegistry.js';
 import { ProfilerFactory } from './Profiler.js';
 const CacheAutoSaveInterval = 600000; // 10 Minutes.
 /* istanbul ignore next */
 /**
  * Manage all tracked documents and errors.
+ *
+ * The four stages of processing a document:
+ * 1. `read` - read the file from the external file system as a `TextDocument`.
+ * 2. `parse` - Parse the `TextDocument` into an `AstNode`.
+ * 3. `bind` - Bind the `AstNode` and populate both the global symbol table and the local symbol tables on the nodes.
+ * 4. `check` (includes `lint`) - Check the `AstNode` with information from the symbol tables.
+ *
+ * **Caching**
+ *
+ * The global symbol table along with a list of file URIs and checksums is cached in memory and is periodically saved to disk.
+ *
+ * The `TextDocument`s and file `AstNode`s (including their local symbol tables) managed by the client are stored in memory until the client sends a `didClose` notification.
+ *
+ * Some `TextDocument`s may be cached to avoid excessive reading from the file system.
+ *
+ * **INIT and READY**
+ *
+ * When a new instance of the {@link Project} class is constructed, its INIT and READY processes are immediately started in serial.
+ *
+ * During the INIT process of the project, the config and language feature initialization are processed.
+ * The Promise returned by the {@link init} function resolves when the INIT process is complete.
+ *
+ * During the READY process of the project, the whole project is analyzed mainly to populate the global symbol table.
+ * The Promise returned by the {@link ready} function resolves when the READY process is complete.
+ *
+ * The following generally happens during the READY process:
+ * 1. A list of file URIs under the project is obtained.
+ * 2. The global symbol cache, if available, is loaded and validated against the know list of files.
+ *    A list of files that need to be (re)processed is returned in this step.
+ * 3. For each files in the new list, the file is read, parsed, bound, and checked.
+ *
+ * **EDITING**
+ *
+ * After the READY process is complete, editing text documents as signaled by the client or the file watcher results in the file being re-processed.
  */
 export class Project {
     static RootSuffix = '/pack.mcmeta';
+    /** Prevent circular binding. */
+    #bindingInProgressUris = new Set();
     #cacheSaverIntervalId;
     cacheService;
-    /**
-     * URI of files that are currently managed by the language client.
-     */
+    /** URI of files that are currently managed by the language client. */
     #clientManagedUris = new Set();
+    #clientManagedDocAndNodes = new Map();
     #configService;
-    #docAndNodes = new Map();
+    #symbolUpToDateUris = new Set();
     #eventEmitter;
     #initializers;
     #initPromise;
@@ -146,9 +180,9 @@ export class Project {
         this.#cacheSaverIntervalId = setInterval(() => this.cacheService.save(), CacheAutoSaveInterval);
         this
             .on('documentUpdated', ({ doc, node }) => {
-            if (!this.#isReady) {
-                return;
-            }
+            // if (!this.#isReady) {
+            // 	return
+            // }
             this.emit('documentErrorred', {
                 doc,
                 errors: FileNode.getErrors(node),
@@ -159,33 +193,31 @@ export class Project {
             if (uri.endsWith(Project.RootSuffix)) {
                 this.updateRoots();
             }
-            this.bind(uri);
-            return this.ensureParsedAndChecked(uri);
+            this.bindUri(uri);
+            return this.ensureBindingStarted(uri);
         })
             .on('fileModified', async ({ uri }) => {
+            this.#symbolUpToDateUris.delete(uri);
             if (this.isOnlyWatched(uri)) {
-                this.#docAndNodes.delete(uri);
-                await this.ensureParsedAndChecked(uri);
+                await this.ensureBindingStarted(uri);
             }
         })
             .on('fileDeleted', ({ uri }) => {
             if (uri.endsWith(Project.RootSuffix)) {
                 this.updateRoots();
             }
+            this.#symbolUpToDateUris.delete(uri);
             this.symbols.clear({ uri });
             this.tryClearingCache(uri);
         })
             .on('ready', () => {
             this.#isReady = true;
-            // Recheck client managed files.
-            const promises = [];
-            for (const uri of this.#clientManagedUris) {
-                const result = this.#docAndNodes.get(uri);
-                if (result) {
-                    promises.push(this.check(result.doc, result.node));
-                }
-            }
-            Promise.all(promises).catch(e => this.logger.error('[Project#ready] Error occurred when rechecking client managed files after ready', e));
+            // // Recheck client managed files after the READY process, as they may have incomplete results and are user-facing.
+            // const promises: Promise<unknown>[] = []
+            // for (const { doc, node } of this.#clientManagedDocAndNodes.values()) {
+            // 	promises.push(this.check(doc, node))
+            // }
+            // Promise.all(promises).catch(e => this.logger.error('[Project#ready] Error occurred when rechecking client managed files after READY', e))
         });
     }
     setInitPromise() {
@@ -291,8 +323,6 @@ export class Project {
         const ready = async () => {
             await this.init();
             const __profiler = this.profilers.get('project#ready');
-            const ensureParsed = this.ensureParsed.bind(this);
-            const ensureChecked = this.ensureChecked.bind(this);
             await Promise.all([
                 listDependencyFiles(),
                 listProjectFiles(),
@@ -300,7 +330,7 @@ export class Project {
             this.#dependencyFiles = new Set(this.fs.listFiles());
             this.#dependencyRoots = new Set(this.fs.listRoots());
             this.updateRoots();
-            __profiler.task('List Files');
+            __profiler.task('List URIs');
             for (const [id, { checksum, registrar }] of this.meta.symbolRegistrars) {
                 const cacheChecksum = this.cacheService.checksums.symbolRegistrars[id];
                 if (cacheChecksum === undefined || checksum !== cacheChecksum) {
@@ -321,24 +351,33 @@ export class Project {
             }
             __profiler.task('Validate Cache');
             if (addedFiles.length > 0) {
-                this.bind(addedFiles);
+                this.bindUri(addedFiles);
             }
             __profiler.task('Bind URIs');
-            const files = [...addedFiles, ...changedFiles]; // FIXME: mcdoc files might need to be parsed and checked before others.
-            // const docAndNodes = (await Promise.all(files.map(uri => limit(ensureParsed, uri)))).filter((r): r is DocAndNode => !!r)
-            const docAndNodes = (await Promise.all(files.map(uri => ensureParsed(uri)))).filter((r) => !!r);
-            __profiler.task('Parse Files');
-            // await Promise.all(docAndNodes.map(({ doc, node }) => limit(ensureChecked, doc, node)))
-            await Promise.all(docAndNodes.map(({ doc, node }) => ensureChecked(doc, node)));
-            __profiler.task('Check Files').finalize();
+            const files = [...addedFiles, ...changedFiles].sort(this.meta.uriSorter);
+            __profiler.task('Sort URIs');
+            const __bindProfiler = this.profilers.get('project#ready#bind', 'top-n', 50);
+            for (const uri of files) {
+                await this.ensureBindingStarted(uri);
+                __bindProfiler.task(uri);
+            }
+            __bindProfiler.finalize();
+            __profiler.task('Bind Files');
+            __profiler.finalize();
             this.emit('ready', {});
         };
         this.#readyPromise = ready();
     }
+    /**
+     * Load the config file and initialize parsers and processors.
+     */
     async init() {
         await this.#initPromise;
         return this;
     }
+    /**
+     * Finish the initial run of parsing, binding, and checking the entire project.
+     */
     async ready() {
         await this.#readyPromise;
         return this;
@@ -367,136 +406,182 @@ export class Project {
     normalizeUri(uri) {
         return this.fs.mapFromDisk(this.externals.uri.normalize(uri));
     }
-    /**
-     * @returns The language ID of the file, or the file extension without the leading dot.
-     */
-    getLanguageID(uri) {
-        uri = this.normalizeUri(uri);
-        const ext = fileUtil.extname(uri) ?? '.plaintext';
-        return this.meta.getLanguageID(ext) ?? ext.slice(1);
-    }
-    /**
-     * @returns The cached `TextDocument` and `AstNode` for the URI, or `undefined` when such data isn't available in cache.
-     */
-    get(uri) {
-        uri = this.normalizeUri(uri);
-        return this.#docAndNodes.get(uri);
+    static TextDocumentCacheMaxLength = 268435456;
+    #textDocumentCache = new Map();
+    #textDocumentCacheLength = 0;
+    removeCachedTextDocument(uri) {
+        const doc = this.#textDocumentCache.get(uri);
+        if (doc && !(doc instanceof Promise)) {
+            this.#textDocumentCacheLength -= doc.getText().length;
+        }
+        this.#textDocumentCache.delete(uri);
     }
-    /**
-     * @throws FS-related errors
-     */
-    async ensureParsed(uri) {
+    async read(uri) {
+        const getLanguageID = (uri) => {
+            const ext = fileUtil.extname(uri) ?? '.plaintext';
+            return this.meta.getLanguageID(ext) ?? ext.slice(1);
+        };
+        const createTextDocument = async (uri) => {
+            const languageId = getLanguageID(uri);
+            if (!this.meta.isSupportedLanguage(languageId)) {
+                return undefined;
+            }
+            try {
+                const content = bufferToString(await this.fs.readFile(uri));
+                return TextDocument.create(uri, languageId, -1, content);
+            }
+            catch (e) {
+                this.logger.warn(`[Project] [read] Failed creating TextDocument for “${uri}”`, e);
+                return undefined;
+            }
+        };
+        const trimCache = () => {
+            const iterator = this.#textDocumentCache.keys();
+            while (this.#textDocumentCacheLength > Project.TextDocumentCacheMaxLength) {
+                const result = iterator.next();
+                if (result.done) {
+                    throw new Error(`[Project] [read] Cache is too large with length ${this.#textDocumentCacheLength} even though it's empty; make sure to call 'removeCachedTextDocument()' instead of 'this.#textDocumentCache.delete()'`);
+                }
+                this.removeCachedTextDocument(result.value);
+            }
+        };
+        const getCacheHandlingPromise = async (uri) => {
+            if (this.#textDocumentCache.has(uri)) {
+                const ans = this.#textDocumentCache.get(uri);
+                // Move the entry to the end of the cache.
+                // The goal is that more-frequently-used entries are preferably not trimmed.
+                this.#textDocumentCache.delete(uri);
+                this.#textDocumentCache.set(uri, ans);
+                return ans;
+            }
+            else {
+                const promise = createTextDocument(uri);
+                this.#textDocumentCache.set(uri, promise);
+                // We replace the Promise in the cache with the TextDocument after it resolves,
+                // or removes it from the cache if it resolves to undefined.
+                const doc = await promise;
+                if (this.#textDocumentCache.get(uri) === promise) {
+                    // The Promise in the cache is the same as the one we created earlier.
+                    // This check is to make sure we don't set a wrong TextDocument to the cache in case the cache was modified elsewhere.
+                    if (doc) {
+                        this.#textDocumentCache.set(uri, doc);
+                        this.#textDocumentCacheLength += doc.getText().length;
+                        trimCache();
+                    }
+                    else {
+                        this.#textDocumentCache.delete(uri);
+                    }
+                }
+                return doc;
+            }
+        };
         uri = this.normalizeUri(uri);
-        if (this.#docAndNodes.has(uri)) {
-            return this.#docAndNodes.get(uri);
-        }
-        const languageID = this.getLanguageID(uri);
-        if (!this.meta.isSupportedLanguage(languageID)) {
-            return undefined;
-        }
-        try {
-            const content = bufferToString(await this.fs.readFile(uri));
-            const doc = TextDocument.create(uri, languageID, -1, content);
-            return this.parseAndCache(doc);
-        }
-        catch (e) {
-            this.logger.warn(`[Project] [ensureParsed] Failed for “${uri}”`, e);
-            return undefined;
+        if (this.#clientManagedUris.has(uri)) {
+            const result = this.#clientManagedDocAndNodes.get(uri);
+            if (result) {
+                return result.doc;
+            }
+            throw new Error(`[Project] [read] Client-managed URI “${uri}” does not have a TextDocument in the cache`);
         }
-    }
-    parseAndCache(doc) {
-        const node = this.parse(doc);
-        return this.cache(doc, node);
+        return getCacheHandlingPromise(uri);
     }
     parse(doc) {
         const ctx = ParserContext.create(this, { doc });
         const src = new Source(doc.getText());
-        let ans;
-        ctx.symbols.clear({ contributor: 'parser', uri: doc.uri });
-        ctx.symbols.contributeAs('parser', () => ans = file()(src, ctx));
-        return ans;
+        const node = file()(src, ctx);
+        return node;
     }
-    cache(doc, node) {
-        const data = { doc, node };
-        this.#docAndNodes.set(doc.uri, data);
-        this.emit('documentUpdated', data);
-        return data;
+    async bind(doc, node) {
+        if (node.binderErrors) {
+            return;
+        }
+        try {
+            this.#bindingInProgressUris.add(doc.uri);
+            const binder = this.meta.getBinder(node.type);
+            const ctx = BinderContext.create(this, { doc });
+            ctx.symbols.clear({ contributor: 'binder', uri: doc.uri });
+            await ctx.symbols.contributeAsAsync('binder', async () => {
+                const proxy = StateProxy.create(node);
+                await binder(proxy, ctx);
+                node.binderErrors = ctx.err.dump();
+            });
+            this.#bindingInProgressUris.delete(doc.uri);
+            this.#symbolUpToDateUris.add(doc.uri);
+        }
+        catch (e) {
+            this.logger.error(`[Project] [bind] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
     }
     async check(doc, node) {
-        const checker = this.meta.getChecker(node.type);
-        const ctx = CheckerContext.create(this, { doc });
-        ctx.symbols.clear({ contributor: 'checker', uri: doc.uri });
-        await ctx.symbols.contributeAsAsync('checker', async () => {
-            await checker(node, ctx);
-            node.checkerErrors = ctx.err.dump();
-            this.cache(doc, node);
-            this.ensureLinted(doc, node);
-        });
-    }
-    async ensureChecked(doc, node) {
-        if (!node.checkerErrors) {
-            try {
-                return this.check(doc, node);
-            }
-            catch (e) {
-                this.logger.error(`[Project] [ensuredChecked] Failed for “${doc.uri}” #${doc.version}`, e);
-            }
+        if (node.checkerErrors) {
+            return;
+        }
+        try {
+            const checker = this.meta.getChecker(node.type);
+            const ctx = CheckerContext.create(this, { doc });
+            ctx.symbols.clear({ contributor: 'checker', uri: doc.uri });
+            await ctx.symbols.contributeAsAsync('checker', async () => {
+                await checker(StateProxy.create(node), ctx);
+                node.checkerErrors = ctx.err.dump();
+                this.lint(doc, node);
+            });
+        }
+        catch (e) {
+            this.logger.error(`[Project] [check] Failed for “${doc.uri}” #${doc.version}`, e);
         }
     }
     lint(doc, node) {
+        if (node.linterErrors) {
+            return;
+        }
         node.linterErrors = [];
-        for (const [ruleName, rawValue] of Object.entries(this.config.lint)) {
-            const result = LinterConfigValue.destruct(rawValue);
-            if (!result) {
-                // Rule is disabled (i.e. set to `null`) in the config.
-                continue;
-            }
-            const { ruleSeverity, ruleValue } = result;
-            const { configValidator, linter, nodePredicate } = this.meta.getLinter(ruleName);
-            if (!configValidator(ruleName, ruleValue, this.logger)) {
-                // Config value is invalid.
-                continue;
-            }
-            const ctx = LinterContext.create(this, {
-                doc,
-                err: new LinterErrorReporter(ruleName, ruleSeverity),
-                ruleName,
-                ruleValue,
-            });
-            traversePreOrder(node, () => true, () => true, node => {
-                if (nodePredicate(node)) {
-                    linter(node, ctx);
+        try {
+            for (const [ruleName, rawValue] of Object.entries(this.config.lint)) {
+                const result = LinterConfigValue.destruct(rawValue);
+                if (!result) {
+                    // Rule is disabled (i.e. set to `null`) in the config.
+                    continue;
                 }
-            });
-            node.linterErrors.push(...ctx.err.dump());
-        }
-        this.cache(doc, node);
-    }
-    ensureLinted(doc, node) {
-        if (!node.linterErrors) {
-            try {
-                this.lint(doc, node);
-            }
-            catch (e) {
-                this.logger.error(`[Project] [ensureLinted] Failed for “${doc.uri}” #${doc.version}`, e);
+                const { ruleSeverity, ruleValue } = result;
+                const { configValidator, linter, nodePredicate } = this.meta.getLinter(ruleName);
+                if (!configValidator(ruleName, ruleValue, this.logger)) {
+                    // Config value is invalid.
+                    continue;
+                }
+                const ctx = LinterContext.create(this, {
+                    doc,
+                    err: new LinterErrorReporter(ruleName, ruleSeverity),
+                    ruleName,
+                    ruleValue,
+                });
+                traversePreOrder(node, () => true, () => true, node => {
+                    if (nodePredicate(node)) {
+                        const proxy = StateProxy.create(node);
+                        linter(proxy, ctx);
+                    }
+                });
+                node.linterErrors.push(...ctx.err.dump());
             }
         }
-    }
-    async ensureParsedAndChecked(uri) {
-        const result = await this.ensureParsed(uri);
-        if (result) {
-            await this.ensureChecked(result.doc, result.node);
+        catch (e) {
+            this.logger.error(`[Project] [lint] Failed for “${doc.uri}” #${doc.version}`, e);
         }
-        return result;
     }
-    async ensureParsedAndCheckedOnlyWhenReady(uri) {
-        const result = await this.ensureParsed(uri);
-        if (this.#isReady && result) {
-            await this.ensureChecked(result.doc, result.node);
+    // @SingletonPromise()
+    async ensureBindingStarted(uri) {
+        if (this.#symbolUpToDateUris.has(uri) || this.#bindingInProgressUris.has(uri)) {
+            return;
         }
-        return result;
+        this.#bindingInProgressUris.add(uri);
+        const doc = await this.read(uri);
+        if (!doc || !(await this.cacheService.hasFileChangedSinceCache(doc))) {
+            return;
+        }
+        const node = this.parse(doc);
+        await this.bind(doc, node);
+        this.emit('documentUpdated', { doc, node });
     }
-    bind(param) {
+    bindUri(param) {
         const ctx = UriBinderContext.create(this);
         if (typeof param === 'string') {
             ctx.symbols.clear({ contributor: 'uri_binder', uri: param });
@@ -511,35 +596,40 @@ export class Project {
     /**
      * Notify that a new document was opened in the editor.
      */
-    onDidOpen(uri, languageID, version, content) {
+    async onDidOpen(uri, languageID, version, content) {
         uri = this.normalizeUri(uri);
         if (!fileUtil.isFileUri(uri)) {
             return; // We only accept `file:` scheme for client-managed URIs.
         }
-        this.#clientManagedUris.add(uri);
         const doc = TextDocument.create(uri, languageID, version, content);
-        const { node } = this.parseAndCache(doc);
+        const node = this.parse(doc);
+        this.#clientManagedUris.add(uri);
+        this.#clientManagedDocAndNodes.set(uri, { doc, node });
         if (this.#isReady) {
-            this.check(doc, node);
+            await this.bind(doc, node);
+            await this.check(doc, node);
         }
     }
     /**
      * Notify that an existing document was changed in the editor.
      * @throws If there is no `TextDocument` corresponding to the URI.
      */
-    onDidChange(uri, changes, version) {
+    async onDidChange(uri, changes, version) {
+        this.#symbolUpToDateUris.delete(uri);
         uri = this.normalizeUri(uri);
         if (!fileUtil.isFileUri(uri)) {
             return; // We only accept `file:` scheme for client-managed URIs.
         }
-        const result = this.get(uri);
-        if (!result) {
-            throw new Error(`Document for “${uri}” is not cached. This should not happen. Did the language client send a didChange notification without sending a didOpen one?`);
+        const doc = this.#clientManagedDocAndNodes.get(uri)?.doc;
+        if (!doc) {
+            throw new Error(`TextDocument for “${uri}” is ${!doc ? 'not cached' : 'a Promise'}. This should not happen. Did the language client send a didChange notification without sending a didOpen one, or is there a logic error on our side resulting the 'read' function overriding the 'TextDocument' created in the 'didOpen' notification handler?`);
         }
-        TextDocument.update(result.doc, changes, version);
-        const { node } = this.parseAndCache(result.doc);
+        TextDocument.update(doc, changes, version);
+        const node = this.parse(doc);
+        this.#clientManagedDocAndNodes.set(uri, { doc, node });
         if (this.#isReady) {
-            this.check(result.doc, node);
+            await this.bind(doc, node);
+            await this.check(doc, node);
         }
     }
     /**
@@ -551,8 +641,23 @@ export class Project {
             return; // We only accept `file:` scheme for client-managed URIs.
         }
         this.#clientManagedUris.delete(uri);
+        this.#clientManagedDocAndNodes.delete(uri);
         this.tryClearingCache(uri);
     }
+    async ensureClientManagedChecked(uri) {
+        const result = this.#clientManagedDocAndNodes.get(uri);
+        if (result && this.#isReady) {
+            const { doc, node } = result;
+            await this.bind(doc, node);
+            await this.check(doc, node);
+            this.emit('documentUpdated', { doc, node });
+            return { doc, node };
+        }
+        return undefined;
+    }
+    getClientManaged(uri) {
+        return this.#clientManagedDocAndNodes.get(uri);
+    }
     async showCacheRoot() {
         if (!this.#cacheRoot) {
             return;
@@ -566,7 +671,7 @@ export class Project {
     }
     tryClearingCache(uri) {
         if (this.shouldRemove(uri)) {
-            this.#docAndNodes.delete(uri);
+            this.removeCachedTextDocument(uri);
             this.emit('documentRemoved', { uri });
         }
     }
@@ -578,18 +683,12 @@ export class Project {
     }
 }
 __decorate([
-    CachePromise()
-], Project.prototype, "ensureParsed", null);
+    SingletonPromise()
+], Project.prototype, "bind", null);
 __decorate([
-    CachePromise()
+    SingletonPromise()
 ], Project.prototype, "check", null);
 __decorate([
-    CachePromise()
-], Project.prototype, "ensureChecked", null);
-__decorate([
-    CachePromise()
-], Project.prototype, "ensureParsedAndChecked", null);
-__decorate([
-    CachePromise()
-], Project.prototype, "ensureParsedAndCheckedOnlyWhenReady", null);
+    SingletonPromise()
+], Project.prototype, "ensureClientManagedChecked", null);
 //# sourceMappingURL=Project.js.map

package/lib/service/Service.d.ts

@@ -1,4 +1,5 @@
 import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type { Logger } from '../common/index.js';
 import type { FileNode } from '../node/index.js';
 import { AstNode } from '../node/index.js';
 import type { Color, ColorInfo, ColorToken, InlayHint, SignatureHelp } from '../processor/index.js';
@@ -6,7 +7,6 @@ import { ColorPresentation } from '../processor/index.js';
 import { Range } from '../source/index.js';
 import type { SymbolUsageType } from '../symbol/index.js';
 import { Hover } from './Hover.js';
-import type { Logger } from './Logger.js';
 import { ProfilerFactory } from './Profiler.js';
 import type { ProjectOptions } from './Project.js';
 import { Project } from './Project.js';

package/lib/service/UriProcessor.d.ts

@@ -0,0 +1,5 @@
+import type { UriBinderContext } from './Context.js';
+export declare type UriBinder = (uris: readonly string[], ctx: UriBinderContext) => void;
+export declare type UriSorterRegistration = (this: void, a: string, b: string, next: UriSorter) => number;
+export declare type UriSorter = (this: void, a: string, b: string) => number;
+//# sourceMappingURL=UriProcessor.d.ts.map

package/lib/service/UriProcessor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=UriProcessor.js.map

package/lib/service/index.d.ts

@@ -7,12 +7,11 @@ export * from './ErrorReporter.js';
 export { FileService, UriProtocolSupporter } from './FileService.js';
 export * from './fileUtil.js';
 export * from './Hover.js';
-export * from './Logger.js';
 export * from './MetaRegistry.js';
-export * from './Operations.js';
 export * from './Profiler.js';
 export * from './Project.js';
 export * from './Service.js';
 export * from './SymbolLocations.js';
 export * from './SymbolRegistrar.js';
+export * from './UriProcessor.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/service/index.js

@@ -8,12 +8,11 @@ export * from './ErrorReporter.js';
 export { FileService } from './FileService.js';
 export * from './fileUtil.js';
 export * from './Hover.js';
-export * from './Logger.js';
 export * from './MetaRegistry.js';
-export * from './Operations.js';
 export * from './Profiler.js';
 export * from './Project.js';
 export * from './Service.js';
 export * from './SymbolLocations.js';
 export * from './SymbolRegistrar.js';
+export * from './UriProcessor.js';
 //# sourceMappingURL=index.js.map