@spyglassmc/core 0.1.2 → 0.4.0

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,6 @@
-/// <reference types="node" />
-import type { Dependency } from './Dependency';
-import type { RootUriString } from './fileUtil';
-import type { Logger } from './Logger';
+import type { Externals, Logger } from '../common/index.js';
+import type { Dependency } from './Dependency.js';
+import type { RootUriString } from './fileUtil.js';
 export interface UriProtocolSupporter {
     /**
      * @throws
@@ -16,7 +15,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 +48,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 +74,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 +116,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

package/lib/service/FileService.js

@@ -1,58 +1,26 @@
-"use strict";
 /* istanbul ignore file */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArchiveUriSupporter = exports.FileUriSupporter = exports.FileServiceImpl = exports.FileService = void 0;
-const crypto_1 = __importDefault(require("crypto"));
-const decompress_1 = __importDefault(require("decompress"));
-const fs_1 = __importStar(require("fs"));
-const globby_1 = __importDefault(require("globby"));
-const path_1 = __importDefault(require("path"));
-const common_1 = require("../common");
-const TwoWayMap_1 = require("../common/TwoWayMap");
-const fileUtil_1 = require("./fileUtil");
-const HashAlgorithm = 'sha1';
-var FileService;
+import { Uri } from '../common/index.js';
+import { TwoWayMap } from '../common/TwoWayMap.js';
+import { fileUtil } from './fileUtil.js';
+export var FileService;
 (function (FileService) {
-    function create(cacheRoot) {
-        const virtualUrisRoot = fileUtil_1.fileUtil.ensureEndingSlash(fileUtil_1.fileUtil.pathToFileUri(path_1.default.join(cacheRoot, 'virtual-uris')));
-        return new FileServiceImpl(virtualUrisRoot);
+    function create(externals, cacheRoot) {
+        const virtualUrisRoot = fileUtil.ensureEndingSlash(new Uri('virtual-uris/', cacheRoot).toString());
+        return new FileServiceImpl(externals, virtualUrisRoot);
     }
     FileService.create = create;
-})(FileService = exports.FileService || (exports.FileService = {}));
-class FileServiceImpl {
-    constructor(virtualUrisRoot) {
+})(FileService || (FileService = {}));
+export class FileServiceImpl {
+    externals;
+    virtualUrisRoot;
+    supporters = new Map();
+    /**
+     * A two-way map from mapped physical URIs to virtual URIs.
+     */
+    map = new TwoWayMap();
+    constructor(externals, virtualUrisRoot) {
+        this.externals = externals;
         this.virtualUrisRoot = virtualUrisRoot;
-        this.supporters = new Map();
-        /**
-         * A two-way map from mapped physical URIs to virtual URIs.
-         */
-        this.map = new TwoWayMap_1.TwoWayMap();
     }
     register(protocol, supporter, force = false) {
         if (!force && this.supporters.has(protocol)) {
@@ -69,7 +37,7 @@ class FileServiceImpl {
      * @returns The protocol if it's supported.
      */
     getSupportedProtocol(uri) {
-        const protocol = new common_1.Uri(uri).protocol;
+        const protocol = new Uri(uri).protocol;
         if (!this.supporters.has(protocol)) {
             throw new Error(`The protocol “${protocol}” is unsupported.`);
         }
@@ -100,7 +68,7 @@ class FileServiceImpl {
         }
     }
     async mapToDisk(virtualUri) {
-        if (fileUtil_1.fileUtil.isFileUri(virtualUri)) {
+        if (fileUtil.isFileUri(virtualUri)) {
             return virtualUri;
         }
         if (!this.virtualUrisRoot) {
@@ -109,9 +77,9 @@ class FileServiceImpl {
         try {
             let mappedUri = this.map.getKey(virtualUri);
             if (mappedUri === undefined) {
-                mappedUri = `${this.virtualUrisRoot}${(0, common_1.getSha1)(virtualUri)}/${fileUtil_1.fileUtil.basename(virtualUri)}`;
+                mappedUri = `${this.virtualUrisRoot}${await this.externals.crypto.getSha1(virtualUri)}/${fileUtil.basename(virtualUri)}`;
                 const buffer = await this.readFile(virtualUri);
-                await fileUtil_1.fileUtil.writeFile(mappedUri, buffer, 0o444);
+                await fileUtil.writeFile(this.externals, mappedUri, buffer, 0o444);
                 this.map.set(mappedUri, virtualUri);
             }
             return mappedUri;
@@ -128,18 +96,21 @@ class FileServiceImpl {
         return this.map.get(mappedUri) ?? mappedUri;
     }
 }
-exports.FileServiceImpl = FileServiceImpl;
-class FileUriSupporter {
-    constructor(roots, files) {
+export class FileUriSupporter {
+    externals;
+    roots;
+    files;
+    protocol = 'file:';
+    constructor(externals, roots, files) {
+        this.externals = externals;
         this.roots = roots;
         this.files = files;
-        this.protocol = 'file:';
     }
     async hash(uri) {
-        return hashFile(uri);
+        return hashFile(this.externals, uri);
     }
     readFile(uri) {
-        return fs_1.promises.readFile(new common_1.Uri(uri));
+        return this.externals.fs.readFile(uri);
     }
     *listFiles() {
         for (const files of this.files.values()) {
@@ -152,54 +123,55 @@ class FileUriSupporter {
     async mapToDisk(uri) {
         return uri;
     }
-    static rootUriToGlob(root) {
-        return fileUtil_1.fileUtil.fileUriToPath(root) + '**/*';
-    }
-    static async create(dependencies, logger) {
+    static async create(dependencies, externals, logger) {
         const roots = [];
         const files = new Map();
         for (let { uri } of dependencies) {
             try {
-                if (fileUtil_1.fileUtil.isFileUri(uri) && (await fs_1.promises.stat(new common_1.Uri(uri))).isDirectory()) {
-                    uri = fileUtil_1.fileUtil.ensureEndingSlash(uri);
+                if (fileUtil.isFileUri(uri) && (await externals.fs.stat(uri)).isDirectory()) {
+                    uri = fileUtil.ensureEndingSlash(uri);
                     roots.push(uri);
-                    files.set(uri, (await (0, globby_1.default)(this.rootUriToGlob(uri), { absolute: true, dot: true })).map(fileUtil_1.fileUtil.pathToFileUri));
+                    files.set(uri, await externals.fs.getAllFiles(uri));
                 }
             }
             catch (e) {
                 logger.error(`[FileUriSupporter#create] Bad dependency “${uri}”`, e);
             }
         }
-        return new FileUriSupporter(roots, files);
+        return new FileUriSupporter(externals, roots, files);
     }
 }
-exports.FileUriSupporter = FileUriSupporter;
 // namespace ArchiveUri {
 // export function is(uri: Uri): boolean {
 // 	return uri.protocol === Protocol && uri.hostname === Hostname
 // }
 // }
-class ArchiveUriSupporter {
+export class ArchiveUriSupporter {
+    externals;
+    entries;
+    static Protocol = 'archive:';
+    static SupportedArchiveExtnames = ['.tar', '.tar.bz2', '.tar.gz', '.zip'];
+    protocol = ArchiveUriSupporter.Protocol;
     /**
      * @param entries A map from archive URIs to unzipped entries.
      */
-    constructor(entries) {
+    constructor(externals, entries) {
+        this.externals = externals;
         this.entries = entries;
-        this.protocol = ArchiveUriSupporter.Protocol;
     }
     async hash(uri) {
-        const { archiveUri, pathInArchive } = ArchiveUriSupporter.decodeUri(new common_1.Uri(uri));
+        const { archiveUri, pathInArchive } = ArchiveUriSupporter.decodeUri(new Uri(uri));
         if (!pathInArchive) {
             // Hash the archive itself.
-            return hashFile(archiveUri);
+            return hashFile(this.externals, archiveUri);
         }
         else {
             // Hash the corresponding file.
-            return (0, common_1.getSha1)(this.getDataInArchive(archiveUri, pathInArchive));
+            return this.externals.crypto.getSha1(this.getDataInArchive(archiveUri, pathInArchive));
         }
     }
     async readFile(uri) {
-        const { archiveUri, pathInArchive } = ArchiveUriSupporter.decodeUri(new common_1.Uri(uri));
+        const { archiveUri, pathInArchive } = ArchiveUriSupporter.decodeUri(new Uri(uri));
         return this.getDataInArchive(archiveUri, pathInArchive);
     }
     /**
@@ -246,22 +218,22 @@ class ArchiveUriSupporter {
             pathInArchive: uri.pathname.charAt(0) === '/' ? uri.pathname.slice(1) : uri.pathname,
         };
     }
-    static async create(dependencies, logger, checksums) {
+    static async create(dependencies, externals, logger, checksums) {
         const entries = new Map();
         for (const { uri, info } of dependencies) {
             try {
-                if (uri.startsWith('file:') && ArchiveUriSupporter.SupportedArchiveExtnames.some(ext => uri.endsWith(ext)) && (await fs_1.promises.stat(new common_1.Uri(uri))).isFile()) {
+                if (uri.startsWith('file:') && ArchiveUriSupporter.SupportedArchiveExtnames.some(ext => uri.endsWith(ext)) && (await externals.fs.stat(uri)).isFile()) {
                     const rootUri = ArchiveUriSupporter.getUri(uri);
                     const cachedChecksum = checksums[rootUri];
                     if (cachedChecksum !== undefined) {
-                        const checksum = await hashFile(uri);
+                        const checksum = await hashFile(externals, uri);
                         if (cachedChecksum === checksum) {
                             // The dependency has not changed since last cache.
                             logger.info(`[SpyglassUriSupporter#create] Skipped decompressing “${uri}” thanks to cache ${checksum}`);
                             continue;
                         }
                     }
-                    const files = await (0, decompress_1.default)(fileUtil_1.fileUtil.fileUriToPath(uri), { strip: typeof info?.startDepth === 'number' ? info.startDepth : 0 });
+                    const files = await externals.archive.decompressBall(await externals.fs.readFile(uri), { stripLevel: typeof info?.startDepth === 'number' ? info.startDepth : 0 });
                     entries.set(uri, new Map(files.map(f => [f.path.replace(/\\/g, '/'), f])));
                 }
             }
@@ -269,19 +241,10 @@ class ArchiveUriSupporter {
                 logger.error(`[SpyglassUriSupporter#create] Bad dependency “${uri}”`, e);
             }
         }
-        return new ArchiveUriSupporter(entries);
+        return new ArchiveUriSupporter(externals, entries);
     }
 }
-exports.ArchiveUriSupporter = ArchiveUriSupporter;
-ArchiveUriSupporter.Protocol = 'archive:';
-ArchiveUriSupporter.SupportedArchiveExtnames = ['.tar', '.tar.bz2', '.tar.gz', '.zip'];
-async function hashFile(uri) {
-    return new Promise((resolve, reject) => {
-        const hash = crypto_1.default.createHash(HashAlgorithm);
-        fs_1.default.createReadStream(new common_1.Uri(uri))
-            .on('data', chunk => hash.update(chunk))
-            .on('end', () => resolve(hash.digest('hex')))
-            .on('error', reject);
-    });
+async function hashFile(externals, uri) {
+    return externals.crypto.getSha1(await externals.fs.readFile(uri));
 }
 //# sourceMappingURL=FileService.js.map

package/lib/service/Hover.d.ts

@@ -1,5 +1,5 @@
-import type { RangeLike } from '../source';
-import { Range } from '../source';
+import type { RangeLike } from '../source/index.js';
+import { Range } from '../source/index.js';
 export interface Hover {
     range: Range;
     markdown: string;