@spyglassmc/core 0.1.2 → 0.2.0

package/lib/service/Context.d.ts

@@ -1,17 +1,17 @@
 import type { TextDocument } from 'vscode-languageserver-textdocument';
-import type { LinterErrorReporter } from '.';
-import type { Range } from '../source';
-import { ReadonlySource } from '../source';
-import type { SymbolTable, SymbolUtil } from '../symbol';
-import type { Config } from './Config';
-import { ErrorReporter } from './ErrorReporter';
-import type { FileService } from './FileService';
-import type { RootUriString } from './fileUtil';
-import type { Logger } from './Logger';
-import type { MetaRegistry } from './MetaRegistry';
-import { Operations } from './Operations';
-import type { ProfilerFactory } from './Profiler';
-import type { DocAndNode, ProjectData } from './Project';
+import type { LinterErrorReporter } from './index.js';
+import type { Range } from '../source/index.js';
+import { ReadonlySource } from '../source/index.js';
+import type { SymbolTable, SymbolUtil } from '../symbol/index.js';
+import type { Config } from './Config.js';
+import { ErrorReporter } from './ErrorReporter.js';
+import type { FileService } from './FileService.js';
+import type { RootUriString } from './fileUtil.js';
+import type { Logger } from './Logger.js';
+import type { MetaRegistry } from './MetaRegistry.js';
+import { Operations } from './Operations.js';
+import type { ProfilerFactory } from './Profiler.js';
+import type { DocAndNode, ProjectData } from './Project.js';
 export interface ContextBase {
     fs: FileService;
     getDocAndNode: (uri: string) => DocAndNode | undefined;

package/lib/service/Context.js

@@ -1,12 +1,9 @@
-"use strict";
 /* istanbul ignore file */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UriBinderContext = exports.SignatureHelpProviderContext = exports.CompleterContext = exports.ColorizerContext = exports.FormatterContext = exports.LinterContext = exports.CheckerContext = exports.ProcessorContext = exports.ParserContext = exports.ContextBase = void 0;
-const processor_1 = require("../processor");
-const source_1 = require("../source");
-const ErrorReporter_1 = require("./ErrorReporter");
-const Operations_1 = require("./Operations");
-var ContextBase;
+import { formatterContextIndentation } from '../processor/index.js';
+import { ReadonlySource } from '../source/index.js';
+import { ErrorReporter } from './ErrorReporter.js';
+import { Operations } from './Operations.js';
+export var ContextBase;
 (function (ContextBase) {
     function create(project) {
         return {
@@ -21,33 +18,33 @@ var ContextBase;
         };
     }
     ContextBase.create = create;
-})(ContextBase = exports.ContextBase || (exports.ContextBase = {}));
-var ParserContext;
+})(ContextBase || (ContextBase = {}));
+export var ParserContext;
 (function (ParserContext) {
     function create(project, opts) {
         return {
             ...ContextBase.create(project),
             config: project.config,
             doc: opts.doc,
-            err: opts.err ?? new ErrorReporter_1.ErrorReporter(),
+            err: opts.err ?? new ErrorReporter(),
             symbols: project.symbols,
         };
     }
     ParserContext.create = create;
-})(ParserContext = exports.ParserContext || (exports.ParserContext = {}));
-var ProcessorContext;
+})(ParserContext || (ParserContext = {}));
+export var ProcessorContext;
 (function (ProcessorContext) {
     function create(project, opts) {
         return {
             ...ContextBase.create(project),
             config: project.config,
             doc: opts.doc,
-            src: opts.src ?? new source_1.ReadonlySource(opts.doc.getText()),
+            src: opts.src ?? new ReadonlySource(opts.doc.getText()),
             symbols: project.symbols,
         };
     }
     ProcessorContext.create = create;
-})(ProcessorContext = exports.ProcessorContext || (exports.ProcessorContext = {}));
+})(ProcessorContext || (ProcessorContext = {}));
 var ProcessorWithRangeContext;
 (function (ProcessorWithRangeContext) {
     function create(project, opts) {
@@ -68,19 +65,19 @@ var ProcessorWithOffsetContext;
     }
     ProcessorWithOffsetContext.create = create;
 })(ProcessorWithOffsetContext || (ProcessorWithOffsetContext = {}));
-var CheckerContext;
+export var CheckerContext;
 (function (CheckerContext) {
     function create(project, opts) {
         return {
             ...ProcessorContext.create(project, opts),
-            err: opts.err ?? new ErrorReporter_1.ErrorReporter(),
-            ops: opts.ops ?? new Operations_1.Operations(),
+            err: opts.err ?? new ErrorReporter(),
+            ops: opts.ops ?? new Operations(),
             ensureChecked: project.ensureParsedAndChecked?.bind(project),
         };
     }
     CheckerContext.create = create;
-})(CheckerContext = exports.CheckerContext || (exports.CheckerContext = {}));
-var LinterContext;
+})(CheckerContext || (CheckerContext = {}));
+export var LinterContext;
 (function (LinterContext) {
     function create(project, opts) {
         return {
@@ -91,8 +88,8 @@ var LinterContext;
         };
     }
     LinterContext.create = create;
-})(LinterContext = exports.LinterContext || (exports.LinterContext = {}));
-var FormatterContext;
+})(LinterContext || (LinterContext = {}));
+export var FormatterContext;
 (function (FormatterContext) {
     function create(project, opts) {
         return {
@@ -100,20 +97,20 @@ var FormatterContext;
             ...opts,
             indentLevel: 0,
             indent(additionalLevels) {
-                return (0, processor_1.formatterContextIndentation)(this, additionalLevels);
+                return formatterContextIndentation(this, additionalLevels);
             },
         };
     }
     FormatterContext.create = create;
-})(FormatterContext = exports.FormatterContext || (exports.FormatterContext = {}));
-var ColorizerContext;
+})(FormatterContext || (FormatterContext = {}));
+export var ColorizerContext;
 (function (ColorizerContext) {
     function create(project, opts) {
         return ProcessorWithRangeContext.create(project, opts);
     }
     ColorizerContext.create = create;
-})(ColorizerContext = exports.ColorizerContext || (exports.ColorizerContext = {}));
-var CompleterContext;
+})(ColorizerContext || (ColorizerContext = {}));
+export var CompleterContext;
 (function (CompleterContext) {
     function create(project, opts) {
         return {
@@ -123,15 +120,15 @@ var CompleterContext;
         };
     }
     CompleterContext.create = create;
-})(CompleterContext = exports.CompleterContext || (exports.CompleterContext = {}));
-var SignatureHelpProviderContext;
+})(CompleterContext || (CompleterContext = {}));
+export var SignatureHelpProviderContext;
 (function (SignatureHelpProviderContext) {
     function create(project, opts) {
         return ProcessorWithOffsetContext.create(project, opts);
     }
     SignatureHelpProviderContext.create = create;
-})(SignatureHelpProviderContext = exports.SignatureHelpProviderContext || (exports.SignatureHelpProviderContext = {}));
-var UriBinderContext;
+})(SignatureHelpProviderContext || (SignatureHelpProviderContext = {}));
+export var UriBinderContext;
 (function (UriBinderContext) {
     function create(project) {
         return {
@@ -140,5 +137,5 @@ var UriBinderContext;
         };
     }
     UriBinderContext.create = create;
-})(UriBinderContext = exports.UriBinderContext || (exports.UriBinderContext = {}));
+})(UriBinderContext || (UriBinderContext = {}));
 //# sourceMappingURL=Context.js.map

package/lib/service/Dependency.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DependencyKey = void 0;
-var DependencyKey;
+export var DependencyKey;
 (function (DependencyKey) {
     function is(value) {
         return value.startsWith('@');
     }
     DependencyKey.is = is;
-})(DependencyKey = exports.DependencyKey || (exports.DependencyKey = {}));
+})(DependencyKey || (DependencyKey = {}));
 //# sourceMappingURL=Dependency.js.map

package/lib/service/Downloader.d.ts

@@ -1,21 +1,16 @@
-/// <reference types="node" />
-import type { Logger } from './Logger';
-declare type RemoteProtocol = 'http:' | 'https:';
-export declare type RemoteUriString = `${RemoteProtocol}${string}`;
-export declare namespace RemoteUriString {
-    function is(value: string): value is RemoteUriString;
-    function getProtocol(uri: RemoteUriString): RemoteProtocol;
-}
+import type { ExternalDownloaderOptions, Externals, RemoteUriString } from '../common/index.js';
+import type { RootUriString } from './fileUtil.js';
+import type { Logger } from './Logger.js';
 export interface DownloaderDownloadOut {
-    cachePath?: string;
+    cacheUri?: string;
     checksum?: string;
 }
 export declare class Downloader {
     #private;
     private readonly cacheRoot;
+    private readonly externals;
     private readonly logger;
-    private readonly lld;
-    constructor(cacheRoot: string, logger: Logger, lld?: LowLevelDownloader);
+    constructor(cacheRoot: RootUriString, externals: Externals, logger: Logger);
     download<R>(job: Job<R>, out?: DownloaderDownloadOut): Promise<R | undefined>;
 }
 interface Job<R> {
@@ -32,37 +27,12 @@ interface Job<R> {
          */
         checksumJob: Omit<Job<string>, 'cache' | 'id'>;
         checksumExtension: `.${string}`;
-        serializer?: (data: Buffer) => Buffer;
-        deserializer?: (cache: Buffer) => Buffer;
+        serializer?: (data: Uint8Array) => Uint8Array;
+        deserializer?: (cache: Uint8Array) => Uint8Array;
     };
-    transformer: (data: Buffer) => PromiseLike<R> | R;
-    options?: LowLevelDownloadOptions;
+    transformer: (data: Uint8Array) => PromiseLike<R> | R;
+    options?: ExternalDownloaderOptions;
     ttl?: number;
 }
-interface LowLevelDownloadOptions {
-    /**
-     * Use an string array to set multiple values to the header.
-     */
-    headers?: Record<string, string | string[]>;
-    timeout?: number;
-}
-export interface LowLevelDownloader {
-    /**
-     * @throws
-     */
-    get(uri: RemoteUriString, options?: LowLevelDownloadOptions): Promise<Buffer>;
-}
-export declare namespace LowLevelDownloader {
-    function create(): LowLevelDownloader;
-    function mock(options: LowLevelDownloaderMockOptions): LowLevelDownloader;
-}
-interface LowLevelDownloaderMockOptions {
-    /**
-     * A record from URIs to fixture data. The {@link LowLevelDownloader.get} only returns a {@link Buffer},
-     * therefore `string` fixtures will be turned into a `Buffer` and `object` fixtures will be transformed
-     * into JSON and then turned into a `Buffer`.
-     */
-    fixtures: Record<RemoteUriString, string | Buffer | object>;
-}
 export {};
 //# sourceMappingURL=Downloader.d.ts.map

package/lib/service/Downloader.js

@@ -1,68 +1,44 @@
-"use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _Downloader_memoryCache;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LowLevelDownloader = exports.Downloader = exports.RemoteUriString = void 0;
-const follow_redirects_1 = require("follow-redirects");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const perf_hooks_1 = require("perf_hooks");
-const common_1 = require("../common");
-const fileUtil_1 = require("./fileUtil");
-var RemoteUriString;
-(function (RemoteUriString) {
-    function is(value) {
-        return value.startsWith('http:') || value.startsWith('https:');
-    }
-    RemoteUriString.is = is;
-    function getProtocol(uri) {
-        return uri.slice(0, uri.indexOf(':') + 1);
-    }
-    RemoteUriString.getProtocol = getProtocol;
-})(RemoteUriString = exports.RemoteUriString || (exports.RemoteUriString = {}));
-class Downloader {
-    constructor(cacheRoot, logger, lld = LowLevelDownloader.create()) {
+import { bufferToString, Uri } from '../common/index.js';
+import { fileUtil } from './fileUtil.js';
+export class Downloader {
+    cacheRoot;
+    externals;
+    logger;
+    #memoryCache = new Map();
+    constructor(cacheRoot, externals, logger) {
         this.cacheRoot = cacheRoot;
+        this.externals = externals;
         this.logger = logger;
-        this.lld = lld;
-        _Downloader_memoryCache.set(this, new Map());
     }
     async download(job, out = {}) {
         const { id, cache, uri, options, transformer, ttl } = job;
-        if (ttl && __classPrivateFieldGet(this, _Downloader_memoryCache, "f").has(uri)) {
-            const { buffer, time } = __classPrivateFieldGet(this, _Downloader_memoryCache, "f").get(uri);
-            if (time <= perf_hooks_1.performance.now() + ttl) {
+        if (ttl && this.#memoryCache.has(uri)) {
+            const { buffer, time } = this.#memoryCache.get(uri);
+            if (time <= performance.now() + ttl) {
                 this.logger.info(`[Downloader] [${id}] Skipped thanks to valid cache in memory`);
                 return await transformer(buffer);
             }
             else {
-                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").delete(uri);
+                this.#memoryCache.delete(uri);
             }
         }
         let checksum;
-        let cachePath;
-        let cacheChecksumPath;
+        let cacheUri;
+        let cacheChecksumUri;
         if (cache) {
             const { checksumJob, checksumExtension } = cache;
-            out.cachePath = cachePath = path_1.default.join(this.cacheRoot, 'downloader', id);
-            cacheChecksumPath = path_1.default.join(this.cacheRoot, 'downloader', id + checksumExtension);
+            out.cacheUri = cacheUri = new Uri(`downloader/${id}`, this.cacheRoot).toString();
+            cacheChecksumUri = new Uri(`downloader/${id}${checksumExtension}`, this.cacheRoot).toString();
             try {
                 out.checksum = checksum = await this.download({ ...checksumJob, id: id + checksumExtension });
                 try {
-                    const cacheChecksum = (0, common_1.bufferToString)(await fileUtil_1.fileUtil.readFile(fileUtil_1.fileUtil.pathToFileUri(cacheChecksumPath)))
+                    const cacheChecksum = bufferToString(await fileUtil.readFile(this.externals, cacheChecksumUri))
                         .slice(0, -1); // Remove ending newline
                     if (checksum === cacheChecksum) {
                         try {
-                            const cachedBuffer = await fileUtil_1.fileUtil.readFile(fileUtil_1.fileUtil.pathToFileUri(cachePath));
+                            const cachedBuffer = await fileUtil.readFile(this.externals, cacheUri);
                             if (ttl) {
-                                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").set(uri, { buffer: cachedBuffer, time: perf_hooks_1.performance.now() });
+                                this.#memoryCache.set(uri, { buffer: cachedBuffer, time: performance.now() });
                             }
                             const deserializer = cache.deserializer ?? (b => b);
                             const ans = await transformer(deserializer(cachedBuffer));
@@ -70,23 +46,23 @@ class Downloader {
                             return ans;
                         }
                         catch (e) {
-                            this.logger.error(`[Downloader] [${id}] Loading cached file “${cachePath}”`, e);
-                            if ((0, common_1.isEnoent)(e)) {
+                            this.logger.error(`[Downloader] [${id}] Loading cached file “${cacheUri}”`, e);
+                            if (this.externals.error.isKind(e, 'ENOENT')) {
                                 // Cache checksum exists, but cached file doesn't.
                                 // Remove the invalid cache checksum.
                                 try {
-                                    await fs_1.promises.unlink(cacheChecksumPath);
+                                    await this.externals.fs.unlink(cacheChecksumUri);
                                 }
                                 catch (e) {
-                                    this.logger.error(`[Downloader] [${id}] Removing invalid cache checksum “${cacheChecksumPath}”`, e);
+                                    this.logger.error(`[Downloader] [${id}] Removing invalid cache checksum “${cacheChecksumUri}”`, e);
                                 }
                             }
                         }
                     }
                 }
                 catch (e) {
-                    if (!(0, common_1.isEnoent)(e)) {
-                        this.logger.error(`[Downloader] [${id}] Loading cache checksum “${cacheChecksumPath}”`, e);
+                    if (!this.externals.error.isKind(e, 'ENOENT')) {
+                        this.logger.error(`[Downloader] [${id}] Loading cache checksum “${cacheChecksumUri}”`, e);
                     }
                 }
             }
@@ -95,25 +71,25 @@ class Downloader {
             }
         }
         try {
-            const buffer = await this.lld.get(uri, options);
+            const buffer = await this.externals.downloader.get(uri, options);
             if (ttl) {
-                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").set(uri, { buffer, time: perf_hooks_1.performance.now() });
+                this.#memoryCache.set(uri, { buffer, time: performance.now() });
             }
-            if (cache && cachePath && cacheChecksumPath) {
+            if (cache && cacheUri && cacheChecksumUri) {
                 if (checksum) {
                     try {
-                        await fileUtil_1.fileUtil.writeFile(fileUtil_1.fileUtil.pathToFileUri(cacheChecksumPath), `${checksum}\n`);
+                        await fileUtil.writeFile(this.externals, cacheChecksumUri, `${checksum}\n`);
                     }
                     catch (e) {
-                        this.logger.error(`[Downloader] [${id}] Saving cache checksum “${cacheChecksumPath}”`, e);
+                        this.logger.error(`[Downloader] [${id}] Saving cache checksum “${cacheChecksumUri}”`, e);
                     }
                 }
                 try {
                     const serializer = cache.serializer ?? (b => b);
-                    await fileUtil_1.fileUtil.writeFile(fileUtil_1.fileUtil.pathToFileUri(cachePath), serializer(buffer));
+                    await fileUtil.writeFile(this.externals, cacheUri, serializer(buffer));
                 }
                 catch (e) {
-                    this.logger.error(`[Downloader] [${id}] Caching file “${cachePath}”`, e);
+                    this.logger.error(`[Downloader] [${id}] Caching file “${cacheUri}”`, e);
                 }
             }
             this.logger.info(`[Downloader] [${id}] Downloaded from “${uri}”`);
@@ -121,69 +97,20 @@ class Downloader {
         }
         catch (e) {
             this.logger.error(`[Downloader] [${id}] Downloading “${uri}”`, e);
-            if (cache && cachePath) {
+            if (cache && cacheUri) {
                 try {
-                    const cachedBuffer = await fileUtil_1.fileUtil.readFile(fileUtil_1.fileUtil.pathToFileUri(cachePath));
+                    const cachedBuffer = await fileUtil.readFile(this.externals, cacheUri);
                     const deserializer = cache.deserializer ?? (b => b);
                     const ans = await transformer(deserializer(cachedBuffer));
-                    this.logger.warn(`[Downloader] [${id}] Fell back to cached file “${cachePath}”`);
+                    this.logger.warn(`[Downloader] [${id}] Fell back to cached file “${cacheUri}”`);
                     return ans;
                 }
                 catch (e) {
-                    this.logger.error(`[Downloader] [${id}] Fallback: loading cached file “${cachePath}”`, e);
+                    this.logger.error(`[Downloader] [${id}] Fallback: loading cached file “${cacheUri}”`, e);
                 }
             }
         }
         return undefined;
     }
 }
-exports.Downloader = Downloader;
-_Downloader_memoryCache = new WeakMap();
-var LowLevelDownloader;
-(function (LowLevelDownloader) {
-    function create() {
-        return new LowLevelDownloaderImpl();
-    }
-    LowLevelDownloader.create = create;
-    function mock(options) {
-        return new LowLevelDownloaderMock(options);
-    }
-    LowLevelDownloader.mock = mock;
-})(LowLevelDownloader = exports.LowLevelDownloader || (exports.LowLevelDownloader = {}));
-class LowLevelDownloaderImpl {
-    get(uri, options = {}) {
-        const protocol = RemoteUriString.getProtocol(uri);
-        return new Promise((resolve, reject) => {
-            const backend = protocol === 'http:' ? follow_redirects_1.http : follow_redirects_1.https;
-            backend.get(uri, options, (res) => {
-                if (res.statusCode !== 200) {
-                    reject(new Error(`Status code ${res.statusCode}: ${res.statusMessage}`));
-                }
-                else {
-                    resolve((0, common_1.promisifyAsyncIterable)(res, chunks => Buffer.concat(chunks)));
-                }
-            });
-        });
-    }
-}
-class LowLevelDownloaderMock {
-    constructor(options) {
-        this.options = options;
-    }
-    async get(uri) {
-        if (!this.options.fixtures[uri]) {
-            throw new Error(`404 not found: ${uri}`);
-        }
-        const fixture = this.options.fixtures[uri];
-        if (Buffer.isBuffer(fixture)) {
-            return fixture;
-        }
-        else if (typeof fixture === 'string') {
-            return Buffer.from(fixture, 'utf-8');
-        }
-        else {
-            return Buffer.from(JSON.stringify(fixture), 'utf-8');
-        }
-    }
-}
 //# sourceMappingURL=Downloader.js.map

package/lib/service/ErrorReporter.d.ts

@@ -1,5 +1,5 @@
-import type { LanguageErrorInfo, RangeLike } from '../source';
-import { ErrorSeverity, LanguageError } from '../source';
+import type { LanguageErrorInfo, RangeLike } from '../source/index.js';
+import { ErrorSeverity, LanguageError } from '../source/index.js';
 export declare class ErrorReporter {
     errors: LanguageError[];
     constructor();

package/lib/service/ErrorReporter.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LinterErrorReporter = exports.ErrorReporter = void 0;
-const locales_1 = require("@spyglassmc/locales");
-const source_1 = require("../source");
-class ErrorReporter {
-    constructor() {
-        this.errors = [];
-    }
+import { localize } from '@spyglassmc/locales';
+import { LanguageError, Range } from '../source/index.js';
+export class ErrorReporter {
+    errors = [];
+    constructor() { }
     /**
      * Reports a new error.
      */
     report(message, range, severity = 3 /* ErrorSeverity.Error */, info) {
-        this.errors.push(source_1.LanguageError.create(message, source_1.Range.get(range), severity, info));
+        this.errors.push(LanguageError.create(message, Range.get(range), severity, info));
     }
     /**
      * @returns All reported errors, and then clears the error stack.
@@ -29,15 +25,16 @@ class ErrorReporter {
         this.errors.push(...reporter.errors);
     }
 }
-exports.ErrorReporter = ErrorReporter;
-class LinterErrorReporter extends ErrorReporter {
+export class LinterErrorReporter extends ErrorReporter {
+    ruleName;
+    ruleSeverity;
     constructor(ruleName, ruleSeverity) {
         super();
         this.ruleName = ruleName;
         this.ruleSeverity = ruleSeverity;
     }
     lint(message, range, info, severityOverride) {
-        return this.report((0, locales_1.localize)('linter.diagnostic-message-wrapper', message, this.ruleName), range, severityOverride ?? this.ruleSeverity, info);
+        return this.report(localize('linter.diagnostic-message-wrapper', message, this.ruleName), range, severityOverride ?? this.ruleSeverity, info);
     }
     static fromErrorReporter(reporter, ruleName, ruleSeverity) {
         const ans = new LinterErrorReporter(ruleName, ruleSeverity);
@@ -45,5 +42,4 @@ class LinterErrorReporter extends ErrorReporter {
         return ans;
     }
 }
-exports.LinterErrorReporter = LinterErrorReporter;
 //# sourceMappingURL=ErrorReporter.js.map

package/lib/service/FileService.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="node" />
-import type { Dependency } from './Dependency';
-import type { RootUriString } from './fileUtil';
-import type { Logger } from './Logger';
+import type { Externals } from '../common/index.js';
+import type { Dependency } from './Dependency.js';
+import type { RootUriString } from './fileUtil.js';
+import type { Logger } from './Logger.js';
 export interface UriProtocolSupporter {
     /**
      * @throws
@@ -16,7 +16,7 @@ export interface UriProtocolSupporter {
      * @returns The content of the file at `uri`.
      * @throws If the URI doesn't exist in the file system.
      */
-    readFile(uri: string): Promise<Buffer>;
+    readFile(uri: string): Promise<Uint8Array>;
     listFiles(): Iterable<string>;
     /**
      * Each URI in this array must end with a slash (`/`).
@@ -49,16 +49,17 @@ export interface FileService extends UriProtocolSupporter {
     mapFromDisk(uri: string): string;
 }
 export declare namespace FileService {
-    function create(cacheRoot: string): FileService;
+    function create(externals: Externals, cacheRoot: RootUriString): FileService;
 }
 export declare class FileServiceImpl implements FileService {
+    private readonly externals;
     private readonly virtualUrisRoot?;
     private readonly supporters;
     /**
      * A two-way map from mapped physical URIs to virtual URIs.
      */
     private readonly map;
-    constructor(virtualUrisRoot?: `${string}/` | undefined);
+    constructor(externals: Externals, virtualUrisRoot?: `${string}/` | undefined);
     register(protocol: Protocol, supporter: UriProtocolSupporter, force?: boolean): void;
     unregister(protocol: Protocol): void;
     /**
@@ -74,36 +75,37 @@ export declare class FileServiceImpl implements FileService {
     /**
      * @throws
      */
-    readFile(uri: string): Promise<Buffer>;
+    readFile(uri: string): Promise<Uint8Array>;
     listFiles(): Generator<string, void, undefined>;
     listRoots(): Generator<`${string}/`, void, undefined>;
     mapToDisk(virtualUri: string): Promise<string | undefined>;
     mapFromDisk(mappedUri: string): string;
 }
 export declare class FileUriSupporter implements UriProtocolSupporter {
+    private readonly externals;
     private readonly roots;
     private readonly files;
     readonly protocol = "file:";
     private constructor();
     hash(uri: string): Promise<string>;
-    readFile(uri: string): Promise<Buffer>;
+    readFile(uri: string): Promise<Uint8Array>;
     listFiles(): Generator<string, void, undefined>;
     listRoots(): `${string}/`[];
     mapToDisk(uri: string): Promise<string | undefined>;
-    private static rootUriToGlob;
-    static create(dependencies: readonly Dependency[], logger: Logger): Promise<FileUriSupporter>;
+    static create(dependencies: readonly Dependency[], externals: Externals, logger: Logger): Promise<FileUriSupporter>;
 }
 export declare class ArchiveUriSupporter implements UriProtocolSupporter {
+    private readonly externals;
     private readonly entries;
-    readonly protocol = "archive:";
     static readonly Protocol = "archive:";
     private static readonly SupportedArchiveExtnames;
+    readonly protocol = "archive:";
     /**
      * @param entries A map from archive URIs to unzipped entries.
      */
     private constructor();
     hash(uri: string): Promise<string>;
-    readFile(uri: string): Promise<Buffer>;
+    readFile(uri: string): Promise<Uint8Array>;
     /**
      * @throws
      */
@@ -115,7 +117,7 @@ export declare class ArchiveUriSupporter implements UriProtocolSupporter {
      * @throws When `uri` has the wrong protocol or hostname.
      */
     private static decodeUri;
-    static create(dependencies: readonly Dependency[], logger: Logger, checksums: Record<RootUriString, string>): Promise<ArchiveUriSupporter>;
+    static create(dependencies: readonly Dependency[], externals: Externals, logger: Logger, checksums: Record<RootUriString, string>): Promise<ArchiveUriSupporter>;
 }
 export {};
 //# sourceMappingURL=FileService.d.ts.map