@spyglassmc/core 0.1.0

package/lib/service/Context.d.ts

@@ -0,0 +1,143 @@
+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 { DocAndNode, ProjectData } from './Project';
+export interface ContextBase {
+    fs: FileService;
+    getDocAndNode: (uri: string) => DocAndNode | undefined;
+    global: SymbolTable;
+    logger: Logger;
+    meta: MetaRegistry;
+    project: Record<string, string>;
+    roots: readonly RootUriString[];
+}
+export declare namespace ContextBase {
+    function create(project: ProjectData): ContextBase;
+}
+export interface ParserContext extends ContextBase {
+    config: Config;
+    doc: TextDocument;
+    err: ErrorReporter;
+    /** @deprecated */
+    symbols: SymbolUtil;
+}
+interface ParserContextOptions {
+    doc: TextDocument;
+    err?: ErrorReporter;
+}
+export declare namespace ParserContext {
+    function create(project: ProjectData, opts: ParserContextOptions): ParserContext;
+}
+export interface ProcessorContext extends ContextBase {
+    config: Config;
+    doc: TextDocument;
+    src: ReadonlySource;
+    /** @deprecated */
+    symbols: SymbolUtil;
+}
+interface ProcessorContextOptions {
+    doc: TextDocument;
+    src?: ReadonlySource;
+}
+export declare namespace ProcessorContext {
+    function create(project: ProjectData, opts: ProcessorContextOptions): ProcessorContext;
+}
+interface ProcessorWithRangeContext extends ProcessorContext {
+    range?: Range;
+}
+interface ProcessorWithRangeContextOptions extends ProcessorContextOptions {
+    range?: Range;
+}
+declare namespace ProcessorWithRangeContext {
+    function create(project: ProjectData, opts: ProcessorWithRangeContextOptions): ProcessorWithRangeContext;
+}
+interface ProcessorWithOffsetContext extends ProcessorContext {
+    offset: number;
+}
+interface ProcessorWithOffsetContextOptions extends ProcessorContextOptions {
+    offset: number;
+}
+declare namespace ProcessorWithOffsetContext {
+    function create(project: ProjectData, opts: ProcessorWithOffsetContextOptions): ProcessorWithOffsetContext;
+}
+export interface CheckerContext extends ProcessorContext {
+    err: ErrorReporter;
+    ops: Operations;
+    ensureChecked: (this: void, uri: string) => Promise<unknown>;
+}
+interface CheckerContextOptions extends ProcessorContextOptions {
+    err?: ErrorReporter;
+    ops?: Operations;
+}
+export declare namespace CheckerContext {
+    function create(project: ProjectData, opts: CheckerContextOptions): CheckerContext;
+}
+export interface LinterContext extends ProcessorContext {
+    err: LinterErrorReporter;
+    ruleName: string;
+    ruleValue: unknown;
+}
+interface LinterContextOptions extends ProcessorContextOptions {
+    err: LinterErrorReporter;
+    ruleName: string;
+    ruleValue: unknown;
+}
+export declare namespace LinterContext {
+    function create(project: ProjectData, opts: LinterContextOptions): LinterContext;
+}
+export interface FormatterContext extends ProcessorContext {
+    tabSize: number;
+    insertSpaces: boolean;
+    indentLevel: number;
+    indent: (additionalLevels?: number) => string;
+}
+interface FormatterContextOptions extends ProcessorContextOptions {
+    tabSize: number;
+    insertSpaces: boolean;
+}
+export declare namespace FormatterContext {
+    function create(project: ProjectData, opts: FormatterContextOptions): FormatterContext;
+}
+export interface ColorizerContext extends ProcessorWithRangeContext {
+}
+export interface ColorizerContextOptions extends ProcessorWithRangeContextOptions {
+}
+export declare namespace ColorizerContext {
+    function create(project: ProjectData, opts: ColorizerContextOptions): ColorizerContext;
+}
+export interface CompleterContext extends ProcessorContext {
+    offset: number;
+    triggerCharacter?: string;
+}
+interface CompleterContextOptions extends ProcessorContextOptions {
+    offset: number;
+    triggerCharacter?: string;
+}
+export declare namespace CompleterContext {
+    function create(project: ProjectData, opts: CompleterContextOptions): CompleterContext;
+}
+export interface SignatureHelpProviderContext extends ProcessorWithOffsetContext {
+}
+export interface SignatureHelpProviderContextOptions extends ProcessorWithOffsetContextOptions {
+}
+export declare namespace SignatureHelpProviderContext {
+    function create(project: ProjectData, opts: SignatureHelpProviderContextOptions): SignatureHelpProviderContext;
+}
+export interface UriBinderContext extends ContextBase {
+    /** @deprecated */
+    symbols: SymbolUtil;
+}
+export declare namespace UriBinderContext {
+    function create(project: ProjectData): UriBinderContext;
+}
+export {};
+//# sourceMappingURL=Context.d.ts.map

package/lib/service/Context.js

@@ -0,0 +1,143 @@
+"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;
+(function (ContextBase) {
+    function create(project) {
+        return {
+            fs: project.fs,
+            getDocAndNode: project.get.bind(project),
+            global: project.symbols.global,
+            logger: project.logger,
+            meta: project.meta,
+            roots: project.roots,
+            project: project.ctx,
+        };
+    }
+    ContextBase.create = create;
+})(ContextBase = exports.ContextBase || (exports.ContextBase = {}));
+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(),
+            symbols: project.symbols,
+        };
+    }
+    ParserContext.create = create;
+})(ParserContext = exports.ParserContext || (exports.ParserContext = {}));
+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()),
+            symbols: project.symbols,
+        };
+    }
+    ProcessorContext.create = create;
+})(ProcessorContext = exports.ProcessorContext || (exports.ProcessorContext = {}));
+var ProcessorWithRangeContext;
+(function (ProcessorWithRangeContext) {
+    function create(project, opts) {
+        return {
+            ...ProcessorContext.create(project, opts),
+            range: opts.range,
+        };
+    }
+    ProcessorWithRangeContext.create = create;
+})(ProcessorWithRangeContext || (ProcessorWithRangeContext = {}));
+var ProcessorWithOffsetContext;
+(function (ProcessorWithOffsetContext) {
+    function create(project, opts) {
+        return {
+            ...ProcessorContext.create(project, opts),
+            offset: opts.offset,
+        };
+    }
+    ProcessorWithOffsetContext.create = create;
+})(ProcessorWithOffsetContext || (ProcessorWithOffsetContext = {}));
+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(),
+            ensureChecked: project.ensureParsedAndChecked?.bind(project),
+        };
+    }
+    CheckerContext.create = create;
+})(CheckerContext = exports.CheckerContext || (exports.CheckerContext = {}));
+var LinterContext;
+(function (LinterContext) {
+    function create(project, opts) {
+        return {
+            ...ProcessorContext.create(project, opts),
+            err: opts.err,
+            ruleName: opts.ruleName,
+            ruleValue: opts.ruleValue,
+        };
+    }
+    LinterContext.create = create;
+})(LinterContext = exports.LinterContext || (exports.LinterContext = {}));
+var FormatterContext;
+(function (FormatterContext) {
+    function create(project, opts) {
+        return {
+            ...ProcessorContext.create(project, opts),
+            ...opts,
+            indentLevel: 0,
+            indent(additionalLevels) {
+                return (0, processor_1.formatterContextIndentation)(this, additionalLevels);
+            },
+        };
+    }
+    FormatterContext.create = create;
+})(FormatterContext = exports.FormatterContext || (exports.FormatterContext = {}));
+var ColorizerContext;
+(function (ColorizerContext) {
+    function create(project, opts) {
+        return ProcessorWithRangeContext.create(project, opts);
+    }
+    ColorizerContext.create = create;
+})(ColorizerContext = exports.ColorizerContext || (exports.ColorizerContext = {}));
+var CompleterContext;
+(function (CompleterContext) {
+    function create(project, opts) {
+        return {
+            ...ProcessorContext.create(project, opts),
+            offset: opts.offset,
+            triggerCharacter: opts.triggerCharacter,
+        };
+    }
+    CompleterContext.create = create;
+})(CompleterContext = exports.CompleterContext || (exports.CompleterContext = {}));
+var SignatureHelpProviderContext;
+(function (SignatureHelpProviderContext) {
+    function create(project, opts) {
+        return ProcessorWithOffsetContext.create(project, opts);
+    }
+    SignatureHelpProviderContext.create = create;
+})(SignatureHelpProviderContext = exports.SignatureHelpProviderContext || (exports.SignatureHelpProviderContext = {}));
+var UriBinderContext;
+(function (UriBinderContext) {
+    function create(project) {
+        return {
+            ...ContextBase.create(project),
+            symbols: project.symbols,
+        };
+    }
+    UriBinderContext.create = create;
+})(UriBinderContext = exports.UriBinderContext || (exports.UriBinderContext = {}));
+//# sourceMappingURL=Context.js.map

package/lib/service/Dependency.d.ts

@@ -0,0 +1,10 @@
+export declare type Dependency = {
+    uri: string;
+    info?: Record<string, any>;
+};
+export declare type DependencyKey = `@${string}`;
+export declare namespace DependencyKey {
+    function is(value: string): value is DependencyKey;
+}
+export declare type DependencyProvider = () => PromiseLike<Dependency> | Dependency;
+//# sourceMappingURL=Dependency.d.ts.map

package/lib/service/Dependency.js

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

package/lib/service/Downloader.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+import type { Logger } from './Logger';
+declare type RemoteProtocol = 'http:' | 'https:';
+export declare type RemoteUriString = `${RemoteProtocol}${string}`;
+export declare namespace RemoteUriString {
+    function getProtocol(uri: RemoteUriString): RemoteProtocol;
+}
+export interface DownloaderDownloadOut {
+    cachePath?: string;
+    checksum?: string;
+}
+export declare class Downloader {
+    #private;
+    private readonly cacheRoot;
+    private readonly logger;
+    private readonly lld;
+    constructor(cacheRoot: string, logger: Logger, lld?: LowLevelDownloader);
+    download<R>(job: Job<R>, out?: DownloaderDownloadOut): Promise<R | undefined>;
+}
+interface Job<R> {
+    /**
+     * A unique ID for the cache.
+     *
+     * It also determines where the file is cached. Use slashes (`/`) to create directories.
+     */
+    id: string;
+    uri: RemoteUriString;
+    cache?: {
+        /**
+         * A download {@link Job} that will return a checksum of the latest remote data.
+         */
+        checksumJob: Omit<Job<string>, 'cache' | 'id'>;
+        checksumExtension: `.${string}`;
+        serializer?: (data: Buffer) => Buffer;
+        deserializer?: (cache: Buffer) => Buffer;
+    };
+    transformer: (data: Buffer) => PromiseLike<R> | R;
+    options?: LowLevelDownloadOptions;
+    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

@@ -0,0 +1,185 @@
+"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 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()) {
+        this.cacheRoot = cacheRoot;
+        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) {
+                this.logger.info(`[Downloader] [${id}] Skipped thanks to valid cache in memory`);
+                return await transformer(buffer);
+            }
+            else {
+                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").delete(uri);
+            }
+        }
+        let checksum;
+        let cachePath;
+        let cacheChecksumPath;
+        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);
+            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)))
+                        .slice(0, -1); // Remove ending newline
+                    if (checksum === cacheChecksum) {
+                        try {
+                            const cachedBuffer = await fileUtil_1.fileUtil.readFile(fileUtil_1.fileUtil.pathToFileUri(cachePath));
+                            if (ttl) {
+                                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").set(uri, { buffer: cachedBuffer, time: perf_hooks_1.performance.now() });
+                            }
+                            const deserializer = cache.deserializer ?? (b => b);
+                            const ans = await transformer(deserializer(cachedBuffer));
+                            this.logger.info(`[Downloader] [${id}] Skipped downloading thanks to cache ${cacheChecksum}`);
+                            return ans;
+                        }
+                        catch (e) {
+                            this.logger.error(`[Downloader] [${id}] Loading cached file “${cachePath}”`, e);
+                            if ((0, common_1.isEnoent)(e)) {
+                                // Cache checksum exists, but cached file doesn't.
+                                // Remove the invalid cache checksum.
+                                try {
+                                    await fs_1.promises.unlink(cacheChecksumPath);
+                                }
+                                catch (e) {
+                                    this.logger.error(`[Downloader] [${id}] Removing invalid cache checksum “${cacheChecksumPath}”`, e);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    if (!(0, common_1.isEnoent)(e)) {
+                        this.logger.error(`[Downloader] [${id}] Loading cache checksum “${cacheChecksumPath}”`, e);
+                    }
+                }
+            }
+            catch (e) {
+                this.logger.error(`[Downloader] [${id}] Fetching latest checksum “${checksumJob.uri}”`, e);
+            }
+        }
+        try {
+            const buffer = await this.lld.get(uri, options);
+            if (ttl) {
+                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").set(uri, { buffer, time: perf_hooks_1.performance.now() });
+            }
+            if (cache && cachePath && cacheChecksumPath) {
+                if (checksum) {
+                    try {
+                        await fileUtil_1.fileUtil.writeFile(fileUtil_1.fileUtil.pathToFileUri(cacheChecksumPath), `${checksum}\n`);
+                    }
+                    catch (e) {
+                        this.logger.error(`[Downloader] [${id}] Saving cache checksum “${cacheChecksumPath}”`, e);
+                    }
+                }
+                try {
+                    const serializer = cache.serializer ?? (b => b);
+                    await fileUtil_1.fileUtil.writeFile(fileUtil_1.fileUtil.pathToFileUri(cachePath), serializer(buffer));
+                }
+                catch (e) {
+                    this.logger.error(`[Downloader] [${id}] Caching file “${cachePath}”`, e);
+                }
+            }
+            this.logger.info(`[Downloader] [${id}] Downloaded from “${uri}”`);
+            return await transformer(buffer);
+        }
+        catch (e) {
+            this.logger.error(`[Downloader] [${id}] Downloading “${uri}”`, e);
+            if (cache && cachePath) {
+                try {
+                    const cachedBuffer = await fileUtil_1.fileUtil.readFile(fileUtil_1.fileUtil.pathToFileUri(cachePath));
+                    const deserializer = cache.deserializer ?? (b => b);
+                    const ans = await transformer(deserializer(cachedBuffer));
+                    this.logger.warn(`[Downloader] [${id}] Fell back to cached file “${cachePath}”`);
+                    return ans;
+                }
+                catch (e) {
+                    this.logger.error(`[Downloader] [${id}] Fallback: loading cached file “${cachePath}”`, 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

@@ -0,0 +1,27 @@
+import type { LanguageErrorInfo, RangeLike } from '../source';
+import { ErrorSeverity, LanguageError } from '../source';
+export declare class ErrorReporter {
+    errors: LanguageError[];
+    constructor();
+    /**
+     * Reports a new error.
+     */
+    report(message: string, range: RangeLike, severity?: ErrorSeverity, info?: LanguageErrorInfo): void;
+    /**
+     * @returns All reported errors, and then clears the error stack.
+     */
+    dump(): readonly LanguageError[];
+    /**
+     * Adds all errors from another reporter's error stack to the current reporter.
+     * This method does not affect the passed-in reporter.
+     */
+    absorb(reporter: ErrorReporter): void;
+}
+export declare class LinterErrorReporter extends ErrorReporter {
+    ruleName: string;
+    ruleSeverity: ErrorSeverity;
+    constructor(ruleName: string, ruleSeverity: ErrorSeverity);
+    lint(message: string, range: RangeLike, info?: LanguageErrorInfo, severityOverride?: ErrorSeverity): void;
+    static fromErrorReporter(reporter: ErrorReporter, ruleName: string, ruleSeverity: ErrorSeverity): LinterErrorReporter;
+}
+//# sourceMappingURL=ErrorReporter.d.ts.map

package/lib/service/ErrorReporter.js

@@ -0,0 +1,49 @@
+"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 = [];
+    }
+    /**
+     * Reports a new error.
+     */
+    report(message, range, severity = 3 /* Error */, info) {
+        this.errors.push(source_1.LanguageError.create(message, source_1.Range.get(range), severity, info));
+    }
+    /**
+     * @returns All reported errors, and then clears the error stack.
+     */
+    dump() {
+        const ans = Object.freeze(this.errors);
+        this.errors = [];
+        return ans;
+    }
+    /**
+     * Adds all errors from another reporter's error stack to the current reporter.
+     * This method does not affect the passed-in reporter.
+     */
+    absorb(reporter) {
+        this.errors.push(...reporter.errors);
+    }
+}
+exports.ErrorReporter = ErrorReporter;
+class LinterErrorReporter extends ErrorReporter {
+    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);
+    }
+    static fromErrorReporter(reporter, ruleName, ruleSeverity) {
+        const ans = new LinterErrorReporter(ruleName, ruleSeverity);
+        ans.errors = reporter.errors;
+        return ans;
+    }
+}
+exports.LinterErrorReporter = LinterErrorReporter;
+//# sourceMappingURL=ErrorReporter.js.map