tstyche 1.0.0-beta.0

package/build/tstyche.js

@@ -0,0 +1,3550 @@
+import { readFileSync, existsSync, writeFileSync, rmSync } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { spawn } from 'node:child_process';
+import { setInterval } from 'node:timers/promises';
+import https from 'node:https';
+
+class EventEmitter {
+    static #handlers = new Set();
+    static addHandler(handler) {
+        EventEmitter.#handlers.add(handler);
+    }
+    static dispatch(event) {
+        for (const handler of EventEmitter.#handlers) {
+            handler(event);
+        }
+    }
+    static removeHandler(handler) {
+        EventEmitter.#handlers.delete(handler);
+    }
+}
+
+class Environment {
+    static #noColor = Environment.#resolveNoColor();
+    static #storePath = Environment.#normalizePath(Environment.#resolveStorePath());
+    static #timeout = Environment.#resolveTimeout();
+    static get noColor() {
+        return Environment.#noColor;
+    }
+    static get storePath() {
+        return Environment.#storePath;
+    }
+    static get timeout() {
+        return Environment.#timeout;
+    }
+    static #normalizePath(value) {
+        if (path.sep === "/") {
+            return value;
+        }
+        return value.replace(/\\/g, "/");
+    }
+    static #parseBoolean(value) {
+        if (value != null) {
+            return ["1", "on", "t", "true", "y", "yes"].includes(value.toLowerCase());
+        }
+        return false;
+    }
+    static #resolveNoColor() {
+        if (process.env["TSTYCHE_NO_COLOR"] != null) {
+            return Environment.#parseBoolean(process.env["TSTYCHE_NO_COLOR"]);
+        }
+        if (process.env["NO_COLOR"] != null && process.env["NO_COLOR"] !== "") {
+            return true;
+        }
+        return false;
+    }
+    static #resolveStorePath() {
+        if (process.env["TSTYCHE_STORE_PATH"] != null) {
+            return path.resolve(process.env["TSTYCHE_STORE_PATH"]);
+        }
+        if (process.platform === "darwin") {
+            return path.resolve(os.homedir(), "Library", "TSTyche");
+        }
+        if (process.env["LocalAppData"] != null) {
+            return path.resolve(process.env["LocalAppData"], "TSTyche");
+        }
+        if (process.env["XDG_DATA_HOME"] != null) {
+            return path.resolve(process.env["XDG_DATA_HOME"], "TSTyche");
+        }
+        return path.resolve(os.homedir(), ".local", "share", "TSTyche");
+    }
+    static #resolveTimeout() {
+        if (process.env["TSTYCHE_TIMEOUT"] != null) {
+            return Number(process.env["TSTYCHE_TIMEOUT"]);
+        }
+        return 30;
+    }
+}
+
+var Color;
+(function (Color) {
+    Color["Reset"] = "0";
+    Color["Red"] = "31";
+    Color["Green"] = "32";
+    Color["Yellow"] = "33";
+    Color["Blue"] = "34";
+    Color["Magenta"] = "35";
+    Color["Cyan"] = "36";
+    Color["Gray"] = "90";
+})(Color || (Color = {}));
+
+class Scribbler {
+    #noColor;
+    constructor(options) {
+        this.#noColor = options?.noColors ?? false;
+    }
+    static createElement(type, props, ...children) {
+        return {
+            $$typeof: Symbol.for("tstyche:scribbler"),
+            children: children.length > 1 ? children : children[0],
+            props,
+            type,
+        };
+    }
+    #escapeSequence(attributes) {
+        return ["\x1b[", Array.isArray(attributes) ? attributes.join(";") : attributes, "m"].join("");
+    }
+    #indentEachLine(lines, level) {
+        const indentStep = "  ";
+        const notEmptyLineRegExp = /^(?!$)/gm;
+        return lines.replace(notEmptyLineRegExp, indentStep.repeat(level));
+    }
+    render(element) {
+        if (element != null) {
+            if (typeof element.type === "function") {
+                const instance = new element.type({
+                    ...element.props,
+                    children: element.children,
+                });
+                return this.render(instance.render());
+            }
+            if (element.type === "ansi" && !this.#noColor) {
+                const flags = typeof element.props?.["escapes"] === "string" || Array.isArray(element.props?.["escapes"])
+                    ? element.props?.["escapes"]
+                    : undefined;
+                if (flags != null) {
+                    return this.#escapeSequence(flags);
+                }
+            }
+            if (element.type === "newline") {
+                return "\r\n";
+            }
+            if (element.type === "text") {
+                const indentLevel = typeof element.props?.["indent"] === "number" ? element.props["indent"] : 0;
+                let text = this.#visitElementChildren(element.children);
+                if (indentLevel > 0) {
+                    text = this.#indentEachLine(text, indentLevel);
+                }
+                return text;
+            }
+        }
+        return "";
+    }
+    #visitElementChildren(children) {
+        if (typeof children === "string") {
+            return children;
+        }
+        if (Array.isArray(children)) {
+            const text = [];
+            for (const child of children) {
+                if (typeof child === "string") {
+                    text.push(child);
+                    continue;
+                }
+                if (Array.isArray(child)) {
+                    text.push(this.#visitElementChildren(child));
+                    continue;
+                }
+                if (child != null && typeof child === "object") {
+                    text.push(this.render(child));
+                    continue;
+                }
+            }
+            return text.join("");
+        }
+        if (children != null && typeof children === "object") {
+            return this.render(children);
+        }
+        return "";
+    }
+}
+
+class Text {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const ansiEscapes = [];
+        if (this.props.color != null) {
+            ansiEscapes.push(this.props.color);
+        }
+        return (Scribbler.createElement("text", { indent: this.props.indent },
+            ansiEscapes.length > 0 ? Scribbler.createElement("ansi", { escapes: ansiEscapes }) : undefined,
+            this.props.children,
+            ansiEscapes.length > 0 ? Scribbler.createElement("ansi", { escapes: "0" }) : undefined));
+    }
+}
+
+class Line {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return (Scribbler.createElement("text", null,
+            Scribbler.createElement(Text, { color: this.props.color, indent: this.props.indent }, this.props.children),
+            Scribbler.createElement("newline", null)));
+    }
+}
+
+function addsPackageStepText(compilerVersion, installationPath) {
+    return (Scribbler.createElement(Line, null,
+        Scribbler.createElement(Text, { color: "90" }, "adds"),
+        " TypeScript ",
+        compilerVersion,
+        Scribbler.createElement(Text, { color: "90" },
+            " to ",
+            installationPath)));
+}
+
+function describeNameText(name, indent = 0) {
+    return Scribbler.createElement(Line, { indent: indent + 1 }, name);
+}
+
+class RelativePathText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const relativePath = path.relative("", this.props.to).replace(/\\/g, "/");
+        if (relativePath === "") {
+            return Scribbler.createElement(Text, null, "./");
+        }
+        return (Scribbler.createElement(Text, null,
+            relativePath.startsWith(".") ? "" : "./",
+            relativePath,
+            this.props.isDirectory === true ? "/" : ""));
+    }
+}
+
+class CodeSpanText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const lastLineInFile = this.props.file.getLineAndCharacterOfPosition(this.props.file.text.length).line;
+        const { character: markedCharacter, line: markedLine } = this.props.file.getLineAndCharacterOfPosition(this.props.start);
+        const firstLine = Math.max(markedLine - 2, 0);
+        const lastLine = Math.min(firstLine + 5, lastLineInFile);
+        const lineNumberMaxWidth = `${lastLine + 1}`.length;
+        const codeSpan = [];
+        for (let i = firstLine; i <= lastLine; i++) {
+            const lineStart = this.props.file.getPositionOfLineAndCharacter(i, 0);
+            const lineEnd = i === lastLineInFile ? this.props.file.text.length : this.props.file.getPositionOfLineAndCharacter(i + 1, 0);
+            const lineNumberText = String(i + 1);
+            const lineText = this.props.file.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
+            if (i === markedLine) {
+                codeSpan.push(Scribbler.createElement(Line, null,
+                    Scribbler.createElement(Text, { color: "31" }, ">"),
+                    " ",
+                    lineNumberText.padStart(lineNumberMaxWidth),
+                    " ",
+                    Scribbler.createElement(Text, { color: "90" }, "|"),
+                    " ",
+                    lineText));
+                codeSpan.push(Scribbler.createElement(Line, null,
+                    " ".repeat(lineNumberMaxWidth + 3),
+                    Scribbler.createElement(Text, { color: "90" }, "|"),
+                    " ".repeat(markedCharacter + 1),
+                    Scribbler.createElement(Text, { color: "31" }, "^")));
+            }
+            else {
+                codeSpan.push(Scribbler.createElement(Line, null,
+                    " ".repeat(2),
+                    Scribbler.createElement(Text, { color: "90" },
+                        lineNumberText.padStart(lineNumberMaxWidth),
+                        " | ",
+                        lineText || "")));
+            }
+        }
+        const breadcrumbs = this.props.breadcrumbs?.flatMap((ancestor) => [
+            Scribbler.createElement(Text, { color: "90" }, " \u276D "),
+            Scribbler.createElement(Text, null, ancestor),
+        ]);
+        const location = (Scribbler.createElement(Line, null,
+            " ".repeat(lineNumberMaxWidth + 5),
+            Scribbler.createElement(Text, { color: "90" }, "at"),
+            " ",
+            Scribbler.createElement(Text, { color: "36" },
+                Scribbler.createElement(RelativePathText, { to: this.props.file.fileName })),
+            Scribbler.createElement(Text, { color: "90" },
+                ":",
+                String(markedLine + 1),
+                ":",
+                String(markedCharacter + 1)),
+            breadcrumbs));
+        return (Scribbler.createElement(Text, null,
+            codeSpan,
+            Scribbler.createElement(Line, null),
+            location));
+    }
+}
+
+class DiagnosticText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const code = typeof this.props.diagnostic.code === "string" ? (Scribbler.createElement(Text, { color: "90" },
+            " ",
+            this.props.diagnostic.code)) : undefined;
+        const text = Array.isArray(this.props.diagnostic.text) ? this.props.diagnostic.text : [this.props.diagnostic.text];
+        const message = text.map((text, index) => (Scribbler.createElement(Text, null,
+            index === 1 ? Scribbler.createElement(Line, null) : undefined,
+            Scribbler.createElement(Line, null,
+                text,
+                code))));
+        const related = this.props.diagnostic.related?.map((relatedDiagnostic) => (Scribbler.createElement(DiagnosticText, { diagnostic: relatedDiagnostic })));
+        const codeSpan = this.props.diagnostic.origin ? (Scribbler.createElement(Text, null,
+            Scribbler.createElement(Line, null),
+            Scribbler.createElement(CodeSpanText, { ...this.props.diagnostic.origin }))) : undefined;
+        return (Scribbler.createElement(Text, null,
+            message,
+            codeSpan,
+            Scribbler.createElement(Line, null),
+            Scribbler.createElement(Text, { indent: 2 }, related)));
+    }
+}
+function diagnosticText(diagnostic) {
+    let prefix;
+    switch (diagnostic.category) {
+        case "error":
+            prefix = Scribbler.createElement(Text, { color: "31" }, "Error: ");
+            break;
+        case "warning":
+            prefix = Scribbler.createElement(Text, { color: "33" }, "Warning: ");
+            break;
+    }
+    return (Scribbler.createElement(Text, null,
+        prefix,
+        Scribbler.createElement(DiagnosticText, { diagnostic: diagnostic })));
+}
+
+class FileNameText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return (Scribbler.createElement(Text, null,
+            Scribbler.createElement(Text, { color: "90" },
+                Scribbler.createElement(RelativePathText, { isDirectory: true, to: path.dirname(this.props.filePath) })),
+            path.basename(this.props.filePath)));
+    }
+}
+function fileStatusText(status, testFile) {
+    let statusColor;
+    let statusText;
+    switch (status) {
+        case "runs":
+            statusColor = "33";
+            statusText = "runs";
+            break;
+        case "passed":
+            statusColor = "32";
+            statusText = "pass";
+            break;
+        case "failed":
+            statusColor = "31";
+            statusText = "fail";
+            break;
+    }
+    return (Scribbler.createElement(Line, null,
+        Scribbler.createElement(Text, { color: statusColor }, statusText),
+        " ",
+        Scribbler.createElement(FileNameText, { filePath: fileURLToPath(testFile) })));
+}
+
+function fileViewText(lines, addEmptyFinalLine) {
+    return (Scribbler.createElement(Text, null,
+        [...lines],
+        addEmptyFinalLine ? Scribbler.createElement(Line, null) : undefined));
+}
+
+class RowText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return (Scribbler.createElement(Line, null,
+            `${this.props.label}:`.padEnd(12),
+            this.props.text));
+    }
+}
+class CountText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return (Scribbler.createElement(Text, null,
+            this.props.failed > 0 ? (Scribbler.createElement(Text, null,
+                Scribbler.createElement(Text, { color: "31" },
+                    String(this.props.failed),
+                    " failed"),
+                Scribbler.createElement(Text, null, ", "))) : undefined,
+            this.props.skipped > 0 ? (Scribbler.createElement(Text, null,
+                Scribbler.createElement(Text, { color: "33" },
+                    String(this.props.skipped),
+                    " skipped"),
+                Scribbler.createElement(Text, null, ", "))) : undefined,
+            this.props.todo > 0 ? (Scribbler.createElement(Text, null,
+                Scribbler.createElement(Text, { color: "35" },
+                    String(this.props.todo),
+                    " todo"),
+                Scribbler.createElement(Text, null, ", "))) : undefined,
+            this.props.passed > 0 ? (Scribbler.createElement(Text, null,
+                Scribbler.createElement(Text, { color: "32" },
+                    String(this.props.passed),
+                    " passed"),
+                Scribbler.createElement(Text, null, ", "))) : undefined,
+            Scribbler.createElement(Text, null,
+                String(this.props.total),
+                Scribbler.createElement(Text, null, " total"))));
+    }
+}
+class DurationText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const duration = this.props.duration / 1000;
+        const minutes = Math.floor(duration / 60);
+        const seconds = duration % 60;
+        return (Scribbler.createElement(Text, null,
+            minutes > 0 ? `${minutes}m ` : undefined,
+            `${Math.round(seconds * 10) / 10}s`));
+    }
+}
+class MatchText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        if (typeof this.props.text === "string") {
+            return Scribbler.createElement(Text, null,
+                "'",
+                this.props.text,
+                "'");
+        }
+        if (this.props.text.length <= 1) {
+            return Scribbler.createElement(Text, null,
+                "'",
+                ...this.props.text,
+                "'");
+        }
+        const lastItem = this.props.text.pop();
+        return (Scribbler.createElement(Text, null,
+            this.props.text.map((match, index, list) => (Scribbler.createElement(Text, null,
+                "'",
+                match,
+                "'",
+                index === list.length - 1 ? Scribbler.createElement(Text, null, " ") : Scribbler.createElement(Text, { color: "90" }, ", ")))),
+            Scribbler.createElement(Text, { color: "90" }, "or"),
+            " '",
+            lastItem,
+            "'"));
+    }
+}
+class RanFilesText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const testNameMatch = [];
+        if (this.props.onlyMatch != null) {
+            testNameMatch.push(Scribbler.createElement(Text, null,
+                Scribbler.createElement(Text, { color: "90" }, "matching "),
+                Scribbler.createElement(MatchText, { text: this.props.onlyMatch })));
+        }
+        if (this.props.skipMatch != null) {
+            testNameMatch.push(Scribbler.createElement(Text, null,
+                this.props.onlyMatch == null ? undefined : Scribbler.createElement(Text, { color: "90" }, " and "),
+                Scribbler.createElement(Text, { color: "90" }, "not matching "),
+                Scribbler.createElement(MatchText, { text: this.props.skipMatch })));
+        }
+        let pathMatch;
+        if (this.props.pathMatch.length > 0) {
+            pathMatch = (Scribbler.createElement(Text, null,
+                Scribbler.createElement(Text, { color: "90" }, "test files matching "),
+                Scribbler.createElement(MatchText, { text: this.props.pathMatch }),
+                Scribbler.createElement(Text, { color: "90" }, ".")));
+        }
+        else {
+            pathMatch = Scribbler.createElement(Text, { color: "90" }, "all test files.");
+        }
+        return (Scribbler.createElement(Line, null,
+            Scribbler.createElement(Text, { color: "90" }, "Ran "),
+            testNameMatch.length > 0 ? Scribbler.createElement(Text, { color: "90" }, "tests ") : undefined,
+            testNameMatch,
+            testNameMatch.length > 0 ? Scribbler.createElement(Text, { color: "90" }, " in ") : undefined,
+            pathMatch));
+    }
+}
+function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, skipMatch, targetCount, testCount, }) {
+    const targetCountText = (Scribbler.createElement(RowText, { label: "Targets", text: Scribbler.createElement(CountText, { failed: targetCount.failed, passed: targetCount.passed, skipped: targetCount.skipped, todo: targetCount.todo, total: targetCount.total }) }));
+    const fileCountText = (Scribbler.createElement(RowText, { label: "Test files", text: Scribbler.createElement(CountText, { failed: fileCount.failed, passed: fileCount.passed, skipped: fileCount.skipped, todo: fileCount.todo, total: fileCount.total }) }));
+    const testCountText = (Scribbler.createElement(RowText, { label: "Tests", text: Scribbler.createElement(CountText, { failed: testCount.failed, passed: testCount.passed, skipped: testCount.skipped, todo: testCount.todo, total: testCount.total }) }));
+    const assertionCountText = (Scribbler.createElement(RowText, { label: "Assertions", text: Scribbler.createElement(CountText, { failed: expectCount.failed, passed: expectCount.passed, skipped: expectCount.skipped, todo: expectCount.todo, total: expectCount.total }) }));
+    return (Scribbler.createElement(Text, null,
+        targetCountText,
+        fileCountText,
+        testCount.total > 0 ? testCountText : undefined,
+        expectCount.total > 0 ? assertionCountText : undefined,
+        Scribbler.createElement(RowText, { label: "Duration", text: Scribbler.createElement(DurationText, { duration: duration }) }),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(RanFilesText, { onlyMatch: onlyMatch, pathMatch: pathMatch, skipMatch: skipMatch })));
+}
+
+class StatusText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        switch (this.props.status) {
+            case "fail":
+                return Scribbler.createElement(Text, { color: "31" }, "\u00D7");
+            case "pass":
+                return Scribbler.createElement(Text, { color: "32" }, "+");
+            case "skip":
+                return Scribbler.createElement(Text, { color: "33" }, "- skip");
+            case "todo":
+                return Scribbler.createElement(Text, { color: "35" }, "- todo");
+        }
+    }
+}
+function testNameText(status, name, indent = 0) {
+    return (Scribbler.createElement(Line, { indent: indent + 1 },
+        Scribbler.createElement(StatusText, { status: status }),
+        " ",
+        Scribbler.createElement(Text, { color: "90" }, name)));
+}
+
+class ProjectNameText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return (Scribbler.createElement(Text, { color: "90" },
+            " with ",
+            Scribbler.createElement(RelativePathText, { to: this.props.filePath })));
+    }
+}
+function usesCompilerStepText(compilerVersion, tsconfigFilePath, options) {
+    const projectPathText = typeof tsconfigFilePath === "string" ? Scribbler.createElement(ProjectNameText, { filePath: tsconfigFilePath }) : undefined;
+    return (Scribbler.createElement(Text, null,
+        options?.prependEmptyLine === true ? Scribbler.createElement(Line, null) : undefined,
+        Scribbler.createElement(Line, null,
+            Scribbler.createElement(Text, { color: "34" }, "uses"),
+            " TypeScript ",
+            compilerVersion,
+            projectPathText),
+        Scribbler.createElement(Line, null)));
+}
+
+class Logger {
+    #noColor;
+    #scribbler;
+    #stderr;
+    #stdout;
+    constructor(options) {
+        this.#noColor = options?.noColor ?? Environment.noColor;
+        this.#stderr = options?.stderr ?? process.stderr;
+        this.#stdout = options?.stdout ?? process.stdout;
+        this.#scribbler = new Scribbler({ noColors: this.#noColor });
+    }
+    eraseLastLine() {
+        if (!this.isInteractive()) {
+            return;
+        }
+        this.#stdout.write("\x1b[1A\x1b[0K");
+    }
+    isInteractive() {
+        if ("isTTY" in this.#stdout && typeof this.#stdout.isTTY === "boolean") {
+            return this.#stdout.isTTY;
+        }
+        return false;
+    }
+    #write(stream, body) {
+        const elements = Array.isArray(body) ? body : [body];
+        for (const element of elements) {
+            if (element.$$typeof !== Symbol.for("tstyche:scribbler")) {
+                return;
+            }
+            stream.write(this.#scribbler.render(element));
+        }
+    }
+    writeError(body) {
+        this.#write(this.#stderr, body);
+    }
+    writeMessage(body) {
+        this.#write(this.#stdout, body);
+    }
+    writeWarning(body) {
+        this.#write(this.#stderr, body);
+    }
+}
+
+class Reporter {
+    resolvedConfig;
+    logger;
+    constructor(resolvedConfig) {
+        this.resolvedConfig = resolvedConfig;
+        this.logger = new Logger();
+    }
+}
+
+class SummaryReporter extends Reporter {
+    handleEvent([eventName, payload]) {
+        switch (eventName) {
+            case "end":
+                this.logger.writeMessage(summaryText({
+                    duration: payload.result.timing.duration,
+                    expectCount: payload.result.expectCount,
+                    fileCount: payload.result.fileCount,
+                    onlyMatch: payload.result.resolvedConfig.only,
+                    pathMatch: payload.result.resolvedConfig.pathMatch,
+                    skipMatch: payload.result.resolvedConfig.skip,
+                    targetCount: payload.result.targetCount,
+                    testCount: payload.result.testCount,
+                }));
+                break;
+        }
+    }
+}
+
+class Diagnostic {
+    text;
+    category;
+    origin;
+    code;
+    related;
+    constructor(text, category, origin) {
+        this.text = text;
+        this.category = category;
+        this.origin = origin;
+    }
+    add(options) {
+        if (options.code != null) {
+            this.code = options.code;
+        }
+        if (options.related != null) {
+            this.related = options.related;
+        }
+        return this;
+    }
+    static error(text, origin) {
+        return new Diagnostic(text, "error", origin);
+    }
+    static fromDiagnostics(diagnostics, compiler) {
+        return diagnostics.map((diagnostic) => {
+            let category;
+            switch (diagnostic.category) {
+                case compiler.DiagnosticCategory.Error:
+                    category = "error";
+                    break;
+                default:
+                    category = "warning";
+            }
+            const code = `ts(${diagnostic.code})`;
+            const text = compiler.flattenDiagnosticMessageText(diagnostic.messageText, "\r\n");
+            if (Diagnostic.isTsDiagnosticWithLocation(diagnostic)) {
+                const origin = {
+                    end: diagnostic.start + diagnostic.length,
+                    file: diagnostic.file,
+                    start: diagnostic.start,
+                };
+                return new Diagnostic(text, category, origin).add({ code });
+            }
+            return new Diagnostic(text, category).add({ code });
+        });
+    }
+    static fromError(text, error) {
+        const messageText = Array.isArray(text) ? text : [text];
+        if (error instanceof Error) {
+            if (error.cause != null) {
+                messageText.push(this.#normalizeMessage(String(error.cause)));
+            }
+            messageText.push(this.#normalizeMessage(String(error.message)));
+            if (error.stack != null) {
+                const stackLines = error.stack
+                    .split("\n")
+                    .slice(1)
+                    .map((line) => line.trimStart());
+                messageText.push(...stackLines);
+            }
+        }
+        return Diagnostic.error(messageText);
+    }
+    static isTsDiagnosticWithLocation(diagnostic) {
+        return diagnostic.file != null && diagnostic.start != null && diagnostic.length != null;
+    }
+    static #normalizeMessage(text) {
+        if (text.endsWith(".")) {
+            return text;
+        }
+        return `${text}.`;
+    }
+    static warning(text, origin) {
+        return new Diagnostic(text, "warning", origin);
+    }
+}
+
+var DiagnosticCategory;
+(function (DiagnosticCategory) {
+    DiagnosticCategory["Error"] = "error";
+    DiagnosticCategory["Warning"] = "warning";
+})(DiagnosticCategory || (DiagnosticCategory = {}));
+
+class FileViewService {
+    #indent = 0;
+    #lines = [];
+    #messages = [];
+    get hasErrors() {
+        return this.#messages.length > 0;
+    }
+    addMessage(message) {
+        if (Array.isArray(message)) {
+            this.#messages.push(...message);
+            return;
+        }
+        this.#messages.push(message);
+    }
+    addTest(status, name) {
+        this.#lines.push(testNameText(status, name, this.#indent));
+    }
+    beginDescribe(name) {
+        this.#lines.push(describeNameText(name, this.#indent));
+        this.#indent++;
+    }
+    endDescribe() {
+        this.#indent--;
+    }
+    getMessages() {
+        return this.#messages;
+    }
+    getViewText(options) {
+        return fileViewText(this.#lines, options?.appendEmptyLine === true || this.hasErrors);
+    }
+    reset() {
+        this.#indent = 0;
+        this.#lines = [];
+        this.#messages = [];
+    }
+}
+
+class ThoroughReporter extends Reporter {
+    #currentCompilerVersion;
+    #currentProjectConfigFilePath;
+    #fileCount = 0;
+    #fileView = new FileViewService();
+    #hasReportedAdds = false;
+    #hasReportedError = false;
+    #isFileViewExpanded = false;
+    get #isLastFile() {
+        return this.#fileCount === 0;
+    }
+    handleEvent([eventName, payload]) {
+        switch (eventName) {
+            case "start":
+                this.#isFileViewExpanded = payload.result.testFiles.length === 1;
+                break;
+            case "store:info":
+                this.logger.writeMessage(addsPackageStepText(payload.compilerVersion, payload.installationPath));
+                this.#hasReportedAdds = true;
+                break;
+            case "store:error":
+                for (const diagnostic of payload.diagnostics) {
+                    this.logger.writeError(diagnosticText(diagnostic));
+                }
+                break;
+            case "target:start":
+                this.#fileCount = payload.result.testFiles.length;
+                break;
+            case "target:end":
+                this.#currentCompilerVersion = undefined;
+                this.#currentProjectConfigFilePath = undefined;
+                break;
+            case "project:info":
+                if (this.#currentCompilerVersion !== payload.compilerVersion ||
+                    this.#currentProjectConfigFilePath !== payload.projectConfigFilePath) {
+                    this.logger.writeMessage(usesCompilerStepText(payload.compilerVersion, payload.projectConfigFilePath, {
+                        prependEmptyLine: this.#currentCompilerVersion != null && !this.#hasReportedAdds && !this.#hasReportedError,
+                    }));
+                    this.#hasReportedAdds = false;
+                    if (payload.projectConfigFilePath == null) {
+                        const text = [
+                            "The default compiler options are used for the following tests files.",
+                            "Make sure that 'tsconfig.json' exists and the test files are included in the program.",
+                        ];
+                        this.logger.writeWarning(diagnosticText(Diagnostic.warning(text)));
+                    }
+                    this.#currentCompilerVersion = payload.compilerVersion;
+                    this.#currentProjectConfigFilePath = payload.projectConfigFilePath;
+                }
+                break;
+            case "project:error":
+                for (const diagnostic of payload.diagnostics) {
+                    this.logger.writeError(diagnosticText(diagnostic));
+                }
+                break;
+            case "file:start":
+                if (this.logger.isInteractive()) {
+                    this.logger.writeMessage(fileStatusText(payload.result.status, payload.result.testFile));
+                }
+                this.#fileCount--;
+                this.#hasReportedError = false;
+                break;
+            case "file:error":
+                for (const diagnostic of payload.diagnostics) {
+                    this.#fileView.addMessage(diagnosticText(diagnostic));
+                }
+                break;
+            case "file:end":
+                this.logger.eraseLastLine();
+                this.logger.writeMessage(fileStatusText(payload.result.status, payload.result.testFile));
+                this.logger.writeMessage(this.#fileView.getViewText({ appendEmptyLine: this.#isLastFile }));
+                if (this.#fileView.hasErrors) {
+                    this.logger.writeError(this.#fileView.getMessages());
+                    this.#hasReportedError = true;
+                }
+                this.#fileView.reset();
+                break;
+            case "describe:start":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.beginDescribe(payload.result.describe.name);
+                }
+                break;
+            case "describe:end":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.endDescribe();
+                }
+                break;
+            case "test:skip":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.addTest("skip", payload.result.test.name);
+                }
+                break;
+            case "test:todo":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.addTest("todo", payload.result.test.name);
+                }
+                break;
+            case "test:error":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.addTest("fail", payload.result.test.name);
+                }
+                for (const diagnostic of payload.diagnostics) {
+                    this.#fileView.addMessage(diagnosticText(diagnostic));
+                }
+                break;
+            case "test:fail":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.addTest("fail", payload.result.test.name);
+                }
+                break;
+            case "test:pass":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.addTest("pass", payload.result.test.name);
+                }
+                break;
+            case "expect:error":
+            case "expect:fail":
+                for (const diagnostic of payload.diagnostics) {
+                    this.#fileView.addMessage(diagnosticText(diagnostic));
+                }
+                break;
+        }
+    }
+}
+
+class ResultTiming {
+    end = Date.now();
+    start = Date.now();
+    get duration() {
+        return this.end - this.start;
+    }
+}
+
+class DescribeResult {
+    describe;
+    parent;
+    results = [];
+    timing = new ResultTiming();
+    constructor(describe, parent) {
+        this.describe = describe;
+        this.parent = parent;
+    }
+}
+
+class ExpectResult {
+    assertion;
+    parent;
+    diagnostics = [];
+    status = "runs";
+    timing = new ResultTiming();
+    constructor(assertion, parent) {
+        this.assertion = assertion;
+        this.parent = parent;
+    }
+}
+
+class ResultCount {
+    failed = 0;
+    passed = 0;
+    skipped = 0;
+    todo = 0;
+    get total() {
+        return this.failed + this.passed + this.skipped + this.todo;
+    }
+}
+
+class FileResult {
+    testFile;
+    diagnostics = [];
+    expectCount = new ResultCount();
+    results = [];
+    status = "runs";
+    testCount = new ResultCount();
+    timing = new ResultTiming();
+    constructor(testFile) {
+        this.testFile = testFile;
+    }
+}
+
+class ProjectResult {
+    compilerVersion;
+    projectConfigFilePath;
+    diagnostics = [];
+    results = [];
+    constructor(compilerVersion, projectConfigFilePath) {
+        this.compilerVersion = compilerVersion;
+        this.projectConfigFilePath = projectConfigFilePath;
+    }
+}
+
+class Result {
+    resolvedConfig;
+    testFiles;
+    expectCount = new ResultCount();
+    fileCount = new ResultCount();
+    results = [];
+    targetCount = new ResultCount();
+    testCount = new ResultCount();
+    timing = new ResultTiming();
+    constructor(resolvedConfig, testFiles) {
+        this.resolvedConfig = resolvedConfig;
+        this.testFiles = testFiles;
+    }
+}
+
+class ResultManager {
+    #describeResult;
+    #expectResult;
+    #fileResult;
+    #projectResult;
+    #result;
+    #targetResult;
+    #testResult;
+    handleEvent([eventName, payload]) {
+        switch (eventName) {
+            case "start":
+                this.#result = payload.result;
+                this.#result.timing.start = Date.now();
+                break;
+            case "end":
+                this.#result.timing.end = Date.now();
+                this.#result = undefined;
+                break;
+            case "target:start":
+                this.#result.results.push(payload.result);
+                this.#targetResult = payload.result;
+                this.#targetResult.timing.start = Date.now();
+                break;
+            case "target:end":
+                if (this.#targetResult.status === "failed") {
+                    this.#result.targetCount.failed++;
+                }
+                else {
+                    this.#result.targetCount.passed++;
+                    this.#targetResult.status = "passed";
+                }
+                this.#targetResult.timing.end = Date.now();
+                this.#targetResult = undefined;
+                break;
+            case "store:error": {
+                if (payload.diagnostics.some(({ category }) => category === "error")) {
+                    this.#targetResult.status = "failed";
+                }
+                break;
+            }
+            case "project:info":
+                {
+                    let projectResult = this.#targetResult.results.get(payload.projectConfigFilePath);
+                    if (!projectResult) {
+                        projectResult = new ProjectResult(payload.compilerVersion, payload.projectConfigFilePath);
+                        this.#targetResult.results.set(payload.projectConfigFilePath, projectResult);
+                    }
+                    this.#projectResult = projectResult;
+                }
+                break;
+            case "project:error":
+                this.#targetResult.status = "failed";
+                this.#projectResult.diagnostics.push(...payload.diagnostics);
+                break;
+            case "file:start":
+                this.#projectResult.results.push(payload.result);
+                this.#fileResult = payload.result;
+                this.#fileResult.timing.start = Date.now();
+                break;
+            case "file:error":
+                this.#targetResult.status = "failed";
+                this.#fileResult.status = "failed";
+                this.#fileResult.diagnostics.push(...payload.diagnostics);
+                break;
+            case "file:end":
+                if (this.#fileResult.status === "failed" ||
+                    this.#fileResult.expectCount.failed > 0 ||
+                    this.#fileResult.testCount.failed > 0) {
+                    this.#result.fileCount.failed++;
+                    this.#targetResult.status = "failed";
+                    this.#fileResult.status = "failed";
+                }
+                else {
+                    this.#result.fileCount.passed++;
+                    this.#fileResult.status = "passed";
+                }
+                this.#fileResult.timing.end = Date.now();
+                this.#fileResult = undefined;
+                break;
+            case "describe:start":
+                if (this.#describeResult) {
+                    this.#describeResult.results.push(payload.result);
+                }
+                else {
+                    this.#fileResult.results.push(payload.result);
+                }
+                this.#describeResult = payload.result;
+                this.#describeResult.timing.start = Date.now();
+                break;
+            case "describe:end":
+                this.#describeResult.timing.end = Date.now();
+                this.#describeResult = this.#describeResult.parent;
+                break;
+            case "test:start":
+                if (this.#describeResult) {
+                    this.#describeResult.results.push(payload.result);
+                }
+                else {
+                    this.#fileResult.results.push(payload.result);
+                }
+                this.#testResult = payload.result;
+                this.#testResult.timing.start = Date.now();
+                break;
+            case "test:error":
+                this.#result.testCount.failed++;
+                this.#fileResult.testCount.failed++;
+                this.#testResult.status = "failed";
+                this.#testResult.diagnostics.push(...payload.diagnostics);
+                this.#testResult.timing.end = Date.now();
+                this.#testResult = undefined;
+                break;
+            case "test:fail":
+                this.#result.testCount.failed++;
+                this.#fileResult.testCount.failed++;
+                this.#testResult.status = "failed";
+                this.#testResult.timing.end = Date.now();
+                this.#testResult = undefined;
+                break;
+            case "test:pass":
+                this.#result.testCount.passed++;
+                this.#fileResult.testCount.passed++;
+                this.#testResult.status = "passed";
+                this.#testResult.timing.end = Date.now();
+                this.#testResult = undefined;
+                break;
+            case "test:skip":
+                this.#result.testCount.skipped++;
+                this.#fileResult.testCount.skipped++;
+                this.#testResult.status = "skipped";
+                this.#testResult.timing.end = Date.now();
+                this.#testResult = undefined;
+                break;
+            case "test:todo":
+                this.#result.testCount.todo++;
+                this.#fileResult.testCount.todo++;
+                this.#testResult.status = "todo";
+                this.#testResult.timing.end = Date.now();
+                this.#testResult = undefined;
+                break;
+            case "expect:start":
+                if (this.#testResult) {
+                    this.#testResult.results.push(payload.result);
+                }
+                else {
+                    this.#fileResult.results.push(payload.result);
+                }
+                this.#expectResult = payload.result;
+                this.#expectResult.timing.start = Date.now();
+                break;
+            case "expect:error":
+                this.#result.expectCount.failed++;
+                this.#fileResult.expectCount.failed++;
+                if (this.#testResult) {
+                    this.#testResult.expectCount.failed++;
+                }
+                this.#expectResult.status = "failed";
+                this.#expectResult.diagnostics.push(...payload.diagnostics);
+                this.#expectResult.timing.end = Date.now();
+                this.#expectResult = undefined;
+                break;
+            case "expect:fail":
+                this.#result.expectCount.failed++;
+                this.#fileResult.expectCount.failed++;
+                if (this.#testResult) {
+                    this.#testResult.expectCount.failed++;
+                }
+                this.#expectResult.status = "failed";
+                this.#expectResult.timing.end = Date.now();
+                this.#expectResult = undefined;
+                break;
+            case "expect:pass":
+                this.#result.expectCount.passed++;
+                this.#fileResult.expectCount.passed++;
+                if (this.#testResult) {
+                    this.#testResult.expectCount.passed++;
+                }
+                this.#expectResult.status = "passed";
+                this.#expectResult.timing.end = Date.now();
+                this.#expectResult = undefined;
+                break;
+            case "expect:skip":
+                this.#result.expectCount.skipped++;
+                this.#fileResult.expectCount.skipped++;
+                if (this.#testResult) {
+                    this.#testResult.expectCount.skipped++;
+                }
+                this.#expectResult.status = "skipped";
+                this.#expectResult.timing.end = Date.now();
+                this.#expectResult = undefined;
+                break;
+        }
+    }
+}
+
+var ResultStatus;
+(function (ResultStatus) {
+    ResultStatus["Runs"] = "runs";
+    ResultStatus["Passed"] = "passed";
+    ResultStatus["Failed"] = "failed";
+    ResultStatus["Skipped"] = "skipped";
+    ResultStatus["Todo"] = "todo";
+})(ResultStatus || (ResultStatus = {}));
+
+class TargetResult {
+    versionTag;
+    testFiles;
+    results = new Map();
+    status = "runs";
+    timing = new ResultTiming();
+    constructor(versionTag, testFiles) {
+        this.versionTag = versionTag;
+        this.testFiles = testFiles;
+    }
+}
+
+class TestResult {
+    test;
+    parent;
+    diagnostics = [];
+    expectCount = new ResultCount();
+    results = [];
+    status = "runs";
+    timing = new ResultTiming();
+    constructor(test, parent) {
+        this.test = test;
+        this.parent = parent;
+    }
+}
+
+class TestMember {
+    brand;
+    node;
+    parent;
+    flags;
+    compiler;
+    diagnostics;
+    members = [];
+    name;
+    typeChecker;
+    constructor(brand, node, parent, flags) {
+        this.brand = brand;
+        this.node = node;
+        this.parent = parent;
+        this.flags = flags;
+        this.compiler = parent.compiler;
+        this.typeChecker = parent.typeChecker;
+        this.diagnostics = this.#mapDiagnostics(node, this.parent);
+        this.name = this.#resolveName(node);
+    }
+    get ancestorNames() {
+        const ancestorNames = [];
+        let ancestor = this.parent;
+        while ("name" in ancestor) {
+            ancestorNames.unshift(ancestor.name);
+            ancestor = ancestor.parent;
+        }
+        return ancestorNames;
+    }
+    #mapDiagnostics(node, parent) {
+        const mapped = [];
+        const unmapped = [];
+        if (node.arguments[1] != null &&
+            parent.compiler.isFunctionLike(node.arguments[1]) &&
+            parent.compiler.isBlock(node.arguments[1].body)) {
+            const blockStart = node.arguments[1].body.getStart();
+            const blockEnd = node.arguments[1].body.getEnd();
+            parent.diagnostics.forEach((diagnostic) => {
+                if (diagnostic.start != null && diagnostic.start >= blockStart && diagnostic.start <= blockEnd) {
+                    mapped.push(diagnostic);
+                }
+                else {
+                    unmapped.push(diagnostic);
+                }
+            });
+            parent.diagnostics = unmapped;
+        }
+        return mapped;
+    }
+    #resolveName(node) {
+        return node.arguments[0] !== undefined && this.compiler.isStringLiteral(node.arguments[0])
+            ? node.arguments[0].text
+            : "";
+    }
+    validate() {
+        const diagnostics = [];
+        const getText = (node) => `'${node.expression.getText()}()' cannot be nested within '${this.node.expression.getText()}()' helper.`;
+        switch (this.brand) {
+            case "expect":
+                break;
+            case "describe":
+                for (const member of this.members) {
+                    if (member.brand === "expect") {
+                        diagnostics.push(Diagnostic.error(getText(member.node), {
+                            end: member.node.getEnd(),
+                            file: member.node.getSourceFile(),
+                            start: member.node.getStart(),
+                        }));
+                    }
+                }
+                break;
+            case "test":
+                for (const member of this.members) {
+                    if (member.brand !== "expect") {
+                        diagnostics.push(Diagnostic.error(getText(member.node), {
+                            end: member.node.getEnd(),
+                            file: member.node.getSourceFile(),
+                            start: member.node.getStart(),
+                        }));
+                    }
+                }
+                break;
+        }
+        return diagnostics;
+    }
+}
+
+class Assertion extends TestMember {
+    matcherNode;
+    modifierNode;
+    notNode;
+    isNot;
+    name = "";
+    constructor(brand, node, parent, flags, matcherNode, modifierNode, notNode) {
+        super(brand, node, parent, flags);
+        this.matcherNode = matcherNode;
+        this.modifierNode = modifierNode;
+        this.notNode = notNode;
+        this.diagnostics = this.#mapDiagnostics();
+        this.isNot = notNode ? true : false;
+    }
+    get ancestorNames() {
+        const ancestorNames = [];
+        if ("ancestorNames" in this.parent) {
+            ancestorNames.push(...this.parent.ancestorNames);
+        }
+        if ("name" in this.parent) {
+            ancestorNames.push(this.parent.name);
+        }
+        return ancestorNames;
+    }
+    get matcherName() {
+        return this.matcherNode.expression.name;
+    }
+    get sourceArguments() {
+        return this.node.arguments;
+    }
+    get sourceType() {
+        if (!this.typeChecker) {
+            return;
+        }
+        if (this.node.typeArguments?.[0]) {
+            return {
+                source: 1,
+                type: this.typeChecker.getTypeFromTypeNode(this.node.typeArguments[0]),
+            };
+        }
+        if (this.node.arguments[0]) {
+            return {
+                source: 0,
+                type: this.typeChecker.getTypeAtLocation(this.node.arguments[0]),
+            };
+        }
+        return;
+    }
+    get targetArguments() {
+        return this.matcherNode.arguments;
+    }
+    get targetType() {
+        if (!this.typeChecker) {
+            return;
+        }
+        if (this.matcherNode.typeArguments?.[0]) {
+            return {
+                source: 1,
+                type: this.typeChecker.getTypeFromTypeNode(this.matcherNode.typeArguments[0]),
+            };
+        }
+        if (this.matcherNode.arguments[0]) {
+            return {
+                source: 0,
+                type: this.typeChecker.getTypeAtLocation(this.matcherNode.arguments[0]),
+            };
+        }
+        return;
+    }
+    #mapDiagnostics() {
+        const mapped = [];
+        const unmapped = [];
+        let argStart;
+        let argEnd;
+        if (this.node.typeArguments?.[0]) {
+            argStart = this.node.typeArguments[0].getStart();
+            argEnd = this.node.typeArguments[0].getEnd();
+        }
+        else if (this.node.arguments[0]) {
+            argStart = this.node.arguments[0].getStart();
+            argEnd = this.node.arguments[0].getEnd();
+        }
+        this.parent.diagnostics.forEach((diagnostic) => {
+            if (diagnostic.start != null && diagnostic.start >= argStart && diagnostic.start <= argEnd) {
+                mapped.push(diagnostic);
+            }
+            else {
+                unmapped.push(diagnostic);
+            }
+        });
+        this.parent.diagnostics = unmapped;
+        return mapped;
+    }
+}
+
+var AssertionSource;
+(function (AssertionSource) {
+    AssertionSource[AssertionSource["Argument"] = 0] = "Argument";
+    AssertionSource[AssertionSource["TypeArgument"] = 1] = "TypeArgument";
+})(AssertionSource || (AssertionSource = {}));
+
+class IdentifierLookup {
+    compiler;
+    #identifiers;
+    #moduleSpecifiers = ['"tstyche"', "'tstyche'"];
+    constructor(compiler, identifiers) {
+        this.compiler = compiler;
+        this.#identifiers = identifiers ?? {
+            namedImports: {
+                context: undefined,
+                describe: undefined,
+                expect: undefined,
+                it: undefined,
+                namespace: undefined,
+                test: undefined,
+            },
+            namespace: undefined,
+        };
+    }
+    clone() {
+        return {
+            namedImports: { ...this.#identifiers.namedImports },
+            namespace: this.#identifiers.namespace,
+        };
+    }
+    handleImportDeclaration(node) {
+        if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
+            node.importClause?.isTypeOnly !== true &&
+            node.importClause?.namedBindings != null) {
+            if (this.compiler.isNamedImports(node.importClause.namedBindings)) {
+                for (const element of node.importClause.namedBindings.elements) {
+                    if (element.isTypeOnly) {
+                        continue;
+                    }
+                    let identifierKey;
+                    if (element.propertyName) {
+                        identifierKey = element.propertyName.getText();
+                    }
+                    else {
+                        identifierKey = element.name.getText();
+                    }
+                    if (identifierKey in this.#identifiers.namedImports) {
+                        this.#identifiers.namedImports[identifierKey] = element.name.getText();
+                    }
+                }
+            }
+            if (this.compiler.isNamespaceImport(node.importClause.namedBindings)) {
+                this.#identifiers.namespace = node.importClause.namedBindings.name.getText();
+            }
+        }
+    }
+    resolveTestMemberMeta(node) {
+        let flags = 0;
+        let expression = node.expression;
+        while (this.compiler.isPropertyAccessExpression(expression)) {
+            if (expression.expression.getText() === this.#identifiers.namespace) {
+                break;
+            }
+            switch (expression.name.getText()) {
+                case "fail":
+                    flags |= 1;
+                    break;
+                case "only":
+                    flags |= 2;
+                    break;
+                case "skip":
+                    flags |= 4;
+                    break;
+                case "todo":
+                    flags |= 8;
+                    break;
+            }
+            expression = expression.expression;
+        }
+        let identifierName;
+        if (this.compiler.isPropertyAccessExpression(expression) &&
+            expression.expression.getText() === this.#identifiers.namespace) {
+            identifierName = expression.name.getText();
+        }
+        else {
+            identifierName = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
+        }
+        if (identifierName == null) {
+            return;
+        }
+        switch (identifierName) {
+            case "context":
+            case "describe":
+                return { brand: "describe", flags };
+            case "it":
+            case "test":
+                return { brand: "test", flags };
+            case "expect":
+                return { brand: "expect", flags };
+        }
+        return;
+    }
+}
+
+class TestTree {
+    compiler;
+    diagnostics;
+    sourceFile;
+    typeChecker;
+    members = [];
+    constructor(compiler, diagnostics, sourceFile, typeChecker) {
+        this.compiler = compiler;
+        this.diagnostics = diagnostics;
+        this.sourceFile = sourceFile;
+        this.typeChecker = typeChecker;
+    }
+    get hasOnly() {
+        function hasOnly(root) {
+            return root.members.some((branch) => branch.flags & 2 || ("members" in branch && hasOnly(branch)));
+        }
+        return hasOnly(this);
+    }
+}
+
+class CollectService {
+    compiler;
+    matcherIdentifiers = [
+        "toBeAny",
+        "toBeAssignable",
+        "toBeBigInt",
+        "toBeBoolean",
+        "toBeNever",
+        "toBeNull",
+        "toBeNumber",
+        "toBeString",
+        "toBeSymbol",
+        "toBeUndefined",
+        "toBeUniqueSymbol",
+        "toBeUnknown",
+        "toBeVoid",
+        "toEqual",
+        "toMatch",
+        "toRaiseError",
+    ];
+    modifierIdentifiers = ["type"];
+    notIdentifier = "not";
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    #collectTestMembers(node, identifiers, parent) {
+        if (this.compiler.isBlock(node)) {
+            this.compiler.forEachChild(node, (node) => {
+                this.#collectTestMembers(node, new IdentifierLookup(this.compiler, identifiers.clone()), parent);
+            });
+            return;
+        }
+        if (this.compiler.isCallExpression(node)) {
+            const meta = identifiers.resolveTestMemberMeta(node);
+            if (meta != null && (meta.brand === "describe" || meta.brand === "test")) {
+                const testMember = new TestMember(meta.brand, node, parent, meta.flags);
+                parent.members.push(testMember);
+                this.compiler.forEachChild(node, (node) => {
+                    this.#collectTestMembers(node, identifiers, testMember);
+                });
+                return;
+            }
+            if (meta != null && meta.brand === "expect") {
+                const modifierNode = this.#getMatchingChainNode(node, this.modifierIdentifiers);
+                if (!modifierNode) {
+                    return;
+                }
+                const notNode = this.#getMatchingChainNode(modifierNode, [this.notIdentifier]);
+                const matcherNode = this.#getMatchingChainNode(notNode ?? modifierNode, this.matcherIdentifiers)?.parent;
+                if (matcherNode == null || !this.#isMatcherNode(matcherNode)) {
+                    return;
+                }
+                parent.members.push(new Assertion(meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode));
+                return;
+            }
+        }
+        if (this.compiler.isImportDeclaration(node)) {
+            identifiers.handleImportDeclaration(node);
+            return;
+        }
+        if (this.compiler.isVariableDeclaration(node)) ;
+        if (this.compiler.isBinaryExpression(node)) ;
+        this.compiler.forEachChild(node, (node) => {
+            this.#collectTestMembers(node, identifiers, parent);
+        });
+    }
+    createTestTree(sourceFile, semanticDiagnostics = [], typeChecker) {
+        const testTree = new TestTree(this.compiler, semanticDiagnostics, sourceFile, typeChecker);
+        this.#collectTestMembers(sourceFile, new IdentifierLookup(this.compiler), testTree);
+        return testTree;
+    }
+    #getMatchingChainNode({ parent }, name) {
+        if (this.compiler.isPropertyAccessExpression(parent) && name.includes(parent.name.getText())) {
+            return parent;
+        }
+        return;
+    }
+    #isMatcherNode(node) {
+        return this.compiler.isCallExpression(node) && this.compiler.isPropertyAccessExpression(node.expression);
+    }
+}
+
+var TestMemberBrand;
+(function (TestMemberBrand) {
+    TestMemberBrand["Describe"] = "describe";
+    TestMemberBrand["Test"] = "test";
+    TestMemberBrand["Expect"] = "expect";
+})(TestMemberBrand || (TestMemberBrand = {}));
+
+var TestMemberFlags;
+(function (TestMemberFlags) {
+    TestMemberFlags[TestMemberFlags["None"] = 0] = "None";
+    TestMemberFlags[TestMemberFlags["Fail"] = 1] = "Fail";
+    TestMemberFlags[TestMemberFlags["Only"] = 2] = "Only";
+    TestMemberFlags[TestMemberFlags["Skip"] = 4] = "Skip";
+    TestMemberFlags[TestMemberFlags["Todo"] = 8] = "Todo";
+})(TestMemberFlags || (TestMemberFlags = {}));
+
+class ProjectService {
+    compiler;
+    #service;
+    constructor(compiler) {
+        this.compiler = compiler;
+        function doNothing() {
+        }
+        function returnFalse() {
+            return false;
+        }
+        function returnUndefined() {
+            return undefined;
+        }
+        const noopWatcher = { close: doNothing };
+        const noopLogger = {
+            close: doNothing,
+            endGroup: doNothing,
+            getLogFileName: returnUndefined,
+            hasLevel: returnFalse,
+            info: doNothing,
+            loggingEnabled: returnFalse,
+            msg: doNothing,
+            perftrc: doNothing,
+            startGroup: doNothing,
+        };
+        const host = {
+            ...compiler.sys,
+            clearImmediate,
+            clearTimeout,
+            setImmediate,
+            setTimeout,
+            watchDirectory: () => noopWatcher,
+            watchFile: () => noopWatcher,
+        };
+        this.#service = new this.compiler.server.ProjectService({
+            cancellationToken: this.compiler.server.nullCancellationToken,
+            host,
+            logger: noopLogger,
+            session: undefined,
+            useInferredProjectPerProjectRoot: true,
+            useSingleInferredProject: false,
+        });
+    }
+    closeFile(filePath) {
+        this.#service.closeClientFile(filePath);
+    }
+    getDefaultProject(filePath) {
+        return this.#service.getDefaultProjectForFile(this.compiler.server.toNormalizedPath(filePath), true);
+    }
+    getLanguageService(filePath) {
+        const project = this.getDefaultProject(filePath);
+        if (!project) {
+            return;
+        }
+        return project.getLanguageService(true);
+    }
+    openFile(filePath, sourceText, projectRootPath) {
+        const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
+        EventEmitter.dispatch([
+            "project:info",
+            { compilerVersion: this.compiler.version, projectConfigFilePath: configFileName },
+        ]);
+        if (configFileErrors && configFileErrors.length > 0) {
+            EventEmitter.dispatch([
+                "project:error",
+                { diagnostics: Diagnostic.fromDiagnostics(configFileErrors, this.compiler) },
+            ]);
+        }
+    }
+}
+
+class Checker {
+    compiler;
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    #assertNonNullish(value, message) {
+        if (value == null) {
+            throw Error(message);
+        }
+    }
+    #assertNonNullishSourceType(assertion) {
+        this.#assertNonNullish(assertion.sourceType, "An argument for 'source' was not provided.");
+    }
+    #assertNonNullishTargetType(assertion) {
+        this.#assertNonNullish(assertion.targetType, "An argument for 'target' was not provided.");
+    }
+    #assertNonNullishTypeChecker(assertion) {
+        this.#assertNonNullish(assertion.typeChecker, "The 'typeChecker' was not provided.");
+    }
+    #assertStringsOrNumbers(nodes) {
+        return nodes.every((expression) => this.compiler.isStringLiteral(expression) || this.compiler.isNumericLiteral(expression));
+    }
+    explain(assertion) {
+        this.#assertNonNullishTypeChecker(assertion);
+        const matcher = assertion.matcherName.getText();
+        const origin = {
+            breadcrumbs: assertion.ancestorNames,
+            end: assertion.matcherName.getEnd(),
+            file: assertion.matcherName.getSourceFile(),
+            start: assertion.matcherName.getStart(),
+        };
+        switch (matcher) {
+            case "toBeAssignable": {
+                this.#assertNonNullishSourceType(assertion);
+                this.#assertNonNullishTargetType(assertion);
+                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
+                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
+                return [
+                    Diagnostic.error(assertion.isNot
+                        ? `Type '${targetTypeText}' is assignable to type '${sourceTypeText}'.`
+                        : `Type '${targetTypeText}' is not assignable to type '${sourceTypeText}'.`, origin),
+                ];
+            }
+            case "toBeAny":
+                return this.#isType(assertion, "any");
+            case "toBeBigInt":
+                return this.#isType(assertion, "bigint");
+            case "toBeBoolean":
+                return this.#isType(assertion, "boolean");
+            case "toBeNever":
+                return this.#isType(assertion, "never");
+            case "toBeNull":
+                return this.#isType(assertion, "null");
+            case "toBeNumber":
+                return this.#isType(assertion, "number");
+            case "toBeString":
+                return this.#isType(assertion, "string");
+            case "toBeSymbol":
+                return this.#isType(assertion, "symbol");
+            case "toBeUndefined":
+                return this.#isType(assertion, "undefined");
+            case "toBeUniqueSymbol":
+                return this.#isType(assertion, "unique symbol");
+            case "toBeUnknown":
+                return this.#isType(assertion, "unknown");
+            case "toBeVoid":
+                return this.#isType(assertion, "void");
+            case "toEqual": {
+                this.#assertNonNullishSourceType(assertion);
+                this.#assertNonNullishTargetType(assertion);
+                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
+                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
+                return [
+                    Diagnostic.error(assertion.isNot
+                        ? `Type '${targetTypeText}' is identical to type '${sourceTypeText}'.`
+                        : `Type '${targetTypeText}' is not identical to type '${sourceTypeText}'.`, origin),
+                ];
+            }
+            case "toMatch": {
+                this.#assertNonNullishSourceType(assertion);
+                this.#assertNonNullishTargetType(assertion);
+                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
+                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
+                return [
+                    Diagnostic.error(assertion.isNot
+                        ? `Type '${targetTypeText}' is a subtype of type '${sourceTypeText}'.`
+                        : `Type '${targetTypeText}' is not a subtype of type '${sourceTypeText}'.`, origin),
+                ];
+            }
+            case "toRaiseError": {
+                this.#assertNonNullishSourceType(assertion);
+                if (!this.#assertStringsOrNumbers(assertion.targetArguments)) {
+                    throw new Error("An argument for 'target' must be of type 'string | number'.");
+                }
+                const sourceText = assertion.sourceType.source === 0 ? "Expression" : "Type definition";
+                if (assertion.diagnostics.length === 0) {
+                    return [Diagnostic.error(`${sourceText} did not raise a type error.`, origin)];
+                }
+                if (assertion.isNot && assertion.targetArguments.length === 0) {
+                    const related = [
+                        Diagnostic.error(`The raised type error${assertion.diagnostics.length === 1 ? "" : "s"}:`),
+                        ...Diagnostic.fromDiagnostics(assertion.diagnostics, this.compiler),
+                    ];
+                    return [
+                        Diagnostic.error(`${sourceText} raised ${assertion.diagnostics.length === 1 ? "a" : assertion.diagnostics.length} type error${assertion.diagnostics.length === 1 ? "" : "s"}.`, origin).add({ related }),
+                    ];
+                }
+                if (assertion.diagnostics.length !== assertion.targetArguments.length) {
+                    const expectedText = assertion.diagnostics.length > assertion.targetArguments.length
+                        ? `only ${assertion.targetArguments.length} type error${assertion.targetArguments.length === 1 ? "" : "s"}`
+                        : `${assertion.targetArguments.length} type error${assertion.targetArguments.length === 1 ? "" : "s"}`;
+                    const foundText = assertion.diagnostics.length > assertion.targetArguments.length
+                        ? `${assertion.diagnostics.length}`
+                        : `only ${assertion.diagnostics.length}`;
+                    const related = [
+                        Diagnostic.error(`The raised type error${assertion.diagnostics.length === 1 ? "" : "s"}:`),
+                        ...Diagnostic.fromDiagnostics(assertion.diagnostics, this.compiler),
+                    ];
+                    const diagnostic = Diagnostic.error(`Expected ${expectedText}, but ${foundText} ${assertion.diagnostics.length === 1 ? "was" : "were"} raised.`, origin).add({
+                        related,
+                    });
+                    return [diagnostic];
+                }
+                const diagnostics = [];
+                assertion.targetArguments.forEach((argument, index) => {
+                    const diagnostic = assertion.diagnostics[index];
+                    if (!diagnostic) {
+                        return;
+                    }
+                    const isMatch = this.#matchExpectedError(diagnostic, argument);
+                    if (!assertion.isNot && !isMatch) {
+                        const expectedText = this.compiler.isStringLiteral(argument)
+                            ? `matching substring '${argument.text}'`
+                            : `with code ${argument.text}`;
+                        const related = [
+                            Diagnostic.error("The raised type error:"),
+                            ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
+                        ];
+                        diagnostics.push(Diagnostic.error(`${sourceText} did not raise a type error ${expectedText}.`, origin).add({ related }));
+                    }
+                    if (assertion.isNot && isMatch) {
+                        const expectedText = this.compiler.isStringLiteral(argument)
+                            ? `matching substring '${argument.text}'`
+                            : `with code ${argument.text}`;
+                        const related = [
+                            Diagnostic.error("The raised type error:"),
+                            ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
+                        ];
+                        diagnostics.push(Diagnostic.error(`${sourceText} raised a type error ${expectedText}.`, origin).add({ related }));
+                    }
+                });
+                return diagnostics;
+            }
+            default:
+                throw new Error(`The '${matcher}' matcher is not supported.`);
+        }
+    }
+    #hasTypeFlag(assertion, targetTypeFlag) {
+        this.#assertNonNullishSourceType(assertion);
+        return Boolean(assertion.sourceType.type.flags & targetTypeFlag);
+    }
+    #isType(assertion, targetText) {
+        this.#assertNonNullishSourceType(assertion);
+        this.#assertNonNullishTypeChecker(assertion);
+        const origin = {
+            breadcrumbs: assertion.ancestorNames,
+            end: assertion.matcherName.getEnd(),
+            file: assertion.matcherName.getSourceFile(),
+            start: assertion.matcherName.getStart(),
+        };
+        const sourceText = assertion.typeChecker.typeToString(assertion.sourceType.type);
+        return [
+            Diagnostic.error(assertion.isNot ? `Type '${sourceText}' is '${targetText}'.` : `Type '${sourceText}' is not '${targetText}'.`, origin),
+        ];
+    }
+    match(assertion) {
+        const matcher = assertion.matcherName.getText();
+        switch (matcher) {
+            case "toBeAssignable":
+                this.#assertNonNullishSourceType(assertion);
+                this.#assertNonNullishTargetType(assertion);
+                this.#assertNonNullish(assertion.typeChecker?.isTypeAssignableTo, "The 'isTypeAssignableTo' method is missing in the provided type checker.");
+                return assertion.typeChecker.isTypeAssignableTo(assertion.targetType.type, assertion.sourceType.type);
+            case "toBeAny": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Any);
+            }
+            case "toBeBigInt": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.BigInt);
+            }
+            case "toBeBoolean": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Boolean);
+            }
+            case "toBeNever": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Never);
+            }
+            case "toBeNull": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Null);
+            }
+            case "toBeNumber": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Number);
+            }
+            case "toBeString": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.String);
+            }
+            case "toBeSymbol": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.ESSymbol);
+            }
+            case "toBeUndefined": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Undefined);
+            }
+            case "toBeUniqueSymbol": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.UniqueESSymbol);
+            }
+            case "toBeUnknown": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Unknown);
+            }
+            case "toBeVoid": {
+                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Void);
+            }
+            case "toEqual": {
+                this.#assertNonNullishSourceType(assertion);
+                this.#assertNonNullishTargetType(assertion);
+                this.#assertNonNullish(assertion.typeChecker?.isTypeIdenticalTo, "The 'isTypeIdenticalTo' method is missing in the provided type checker.");
+                return assertion.typeChecker.isTypeIdenticalTo(assertion.sourceType.type, assertion.targetType.type);
+            }
+            case "toMatch": {
+                this.#assertNonNullishSourceType(assertion);
+                this.#assertNonNullishTargetType(assertion);
+                this.#assertNonNullish(assertion.typeChecker?.isTypeSubtypeOf, "The 'isTypeSubtypeOf' method is missing in the provided type checker.");
+                return assertion.typeChecker.isTypeSubtypeOf(assertion.sourceType.type, assertion.targetType.type);
+            }
+            case "toRaiseError": {
+                if (!this.#assertStringsOrNumbers(assertion.targetArguments)) {
+                    throw new Error("An argument for 'target' must be of type 'string | number'.");
+                }
+                if (assertion.targetArguments.length === 0) {
+                    return assertion.diagnostics.length > 0;
+                }
+                if (assertion.diagnostics.length !== assertion.targetArguments.length) {
+                    return false;
+                }
+                return assertion.targetArguments.every((expectedArgument, index) => {
+                    if (this.compiler.isStringLiteral(expectedArgument)) {
+                        return this.compiler
+                            .flattenDiagnosticMessageText(assertion.diagnostics[index]?.messageText, " ", 0)
+                            .includes(expectedArgument.text);
+                    }
+                    if (this.compiler.isNumericLiteral(expectedArgument)) {
+                        return Number(expectedArgument.text) === assertion.diagnostics[index]?.code;
+                    }
+                    return false;
+                });
+            }
+            default:
+                throw new Error(`The '${matcher}' matcher is not supported.`);
+        }
+    }
+    #matchExpectedError(diagnostic, argument) {
+        if (this.compiler.isStringLiteral(argument)) {
+            return this.compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0).includes(argument.text);
+        }
+        if (this.compiler.isNumericLiteral(argument)) {
+            return Number(argument.text) === diagnostic.code;
+        }
+        throw new Error("An argument for 'target' must be of type 'string | number'.");
+    }
+}
+
+class TestTreeWorker {
+    resolvedConfig;
+    compiler;
+    #checker;
+    #fileResult;
+    #hasOnly;
+    #position;
+    #signal;
+    constructor(resolvedConfig, compiler, options) {
+        this.resolvedConfig = resolvedConfig;
+        this.compiler = compiler;
+        this.#checker = new Checker(compiler);
+        this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
+        this.#position = options.position;
+        this.#signal = options.signal;
+        this.#fileResult = options.fileResult;
+    }
+    #resolveRunMode(mode, member) {
+        if (member.flags & 1) {
+            mode |= 1;
+        }
+        if (member.flags & 2 ||
+            (this.resolvedConfig.only != null &&
+                member.name.toLowerCase().includes(this.resolvedConfig.only.toLowerCase())) ||
+            (this.#position != null && member.node.getStart() === this.#position)) {
+            mode |= 2;
+        }
+        if (member.flags & 4 ||
+            (this.resolvedConfig.skip != null && member.name.toLowerCase().includes(this.resolvedConfig.skip.toLowerCase()))) {
+            mode |= 4;
+        }
+        if (member.flags & 8) {
+            mode |= 8;
+        }
+        return mode;
+    }
+    visit(members, runMode, parentResult) {
+        for (const member of members) {
+            if (this.#signal?.aborted === true) {
+                break;
+            }
+            const validationError = member.validate();
+            if (validationError.length > 0) {
+                EventEmitter.dispatch([
+                    "file:error",
+                    {
+                        diagnostics: validationError,
+                        result: this.#fileResult,
+                    },
+                ]);
+                break;
+            }
+            switch (member.brand) {
+                case "describe":
+                    this.#visitDescribe(member, runMode, parentResult);
+                    break;
+                case "test":
+                    this.#visitTest(member, runMode, parentResult);
+                    break;
+                case "expect":
+                    this.#visitAssertion(member, runMode, parentResult);
+                    break;
+            }
+        }
+    }
+    #visitAssertion(assertion, runMode, parentResult) {
+        const expectResult = new ExpectResult(assertion, parentResult);
+        EventEmitter.dispatch(["expect:start", { result: expectResult }]);
+        runMode = this.#resolveRunMode(runMode, assertion);
+        if (runMode & 4 || (this.#hasOnly && !(runMode & 2))) {
+            EventEmitter.dispatch(["expect:skip", { result: expectResult }]);
+            return;
+        }
+        if (assertion.diagnostics.length > 0 && assertion.matcherName.getText() !== "toRaiseError") {
+            EventEmitter.dispatch([
+                "expect:error",
+                {
+                    diagnostics: Diagnostic.fromDiagnostics(assertion.diagnostics, this.compiler),
+                    result: expectResult,
+                },
+            ]);
+            return;
+        }
+        const isPass = this.#checker.match(assertion);
+        if (assertion.isNot ? !isPass : isPass) {
+            if (runMode & 1) {
+                const text = ["The assertion was supposed to fail, but it passed.", "Consider removing the '.fail' flag."];
+                const origin = {
+                    end: assertion.node.getEnd(),
+                    file: assertion.node.getSourceFile(),
+                    start: assertion.node.getStart(),
+                };
+                EventEmitter.dispatch([
+                    "expect:error",
+                    {
+                        diagnostics: [Diagnostic.error(text, origin)],
+                        result: expectResult,
+                    },
+                ]);
+            }
+            else {
+                EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
+            }
+        }
+        else {
+            if (runMode & 1) {
+                EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
+            }
+            else {
+                EventEmitter.dispatch([
+                    "expect:fail",
+                    {
+                        diagnostics: this.#checker.explain(assertion),
+                        result: expectResult,
+                    },
+                ]);
+            }
+        }
+    }
+    #visitDescribe(describe, runMode, parentResult) {
+        const describeResult = new DescribeResult(describe, parentResult);
+        EventEmitter.dispatch(["describe:start", { result: describeResult }]);
+        runMode = this.#resolveRunMode(runMode, describe);
+        if (!(runMode & 4 || runMode & 8) && describe.diagnostics.length > 0) {
+            EventEmitter.dispatch([
+                "file:error",
+                {
+                    diagnostics: Diagnostic.fromDiagnostics(describe.diagnostics, this.compiler),
+                    result: this.#fileResult,
+                },
+            ]);
+        }
+        else {
+            this.visit(describe.members, runMode, describeResult);
+        }
+        EventEmitter.dispatch(["describe:end", { result: describeResult }]);
+    }
+    #visitTest(test, runMode, parentResult) {
+        const testResult = new TestResult(test, parentResult);
+        EventEmitter.dispatch(["test:start", { result: testResult }]);
+        runMode = this.#resolveRunMode(runMode, test);
+        if (runMode & 8) {
+            EventEmitter.dispatch(["test:todo", { result: testResult }]);
+            return;
+        }
+        if (runMode & 4) {
+            EventEmitter.dispatch(["test:skip", { result: testResult }]);
+            return;
+        }
+        if (test.diagnostics.length > 0) {
+            EventEmitter.dispatch([
+                "test:error",
+                {
+                    diagnostics: Diagnostic.fromDiagnostics(test.diagnostics, this.compiler),
+                    result: testResult,
+                },
+            ]);
+            return;
+        }
+        this.visit(test.members, runMode, testResult);
+        if (testResult.expectCount.skipped > 0 && testResult.expectCount.skipped === testResult.expectCount.total) {
+            EventEmitter.dispatch(["test:skip", { result: testResult }]);
+            return;
+        }
+        if (testResult.expectCount.failed > 0) {
+            EventEmitter.dispatch(["test:fail", { result: testResult }]);
+        }
+        else {
+            EventEmitter.dispatch(["test:pass", { result: testResult }]);
+        }
+    }
+}
+
+class TestFileRunner {
+    resolvedConfig;
+    compiler;
+    #collectService;
+    #projectService;
+    constructor(resolvedConfig, compiler) {
+        this.resolvedConfig = resolvedConfig;
+        this.compiler = compiler;
+        this.#collectService = new CollectService(compiler);
+        this.#projectService = new ProjectService(compiler);
+    }
+    run(testFile, signal) {
+        if (signal?.aborted === true) {
+            return;
+        }
+        const testFilePath = fileURLToPath(testFile);
+        const position = testFile.searchParams.has("position") ? Number(testFile.searchParams.get("position")) : undefined;
+        this.#projectService.openFile(testFilePath, undefined, this.resolvedConfig.rootPath);
+        const fileResult = new FileResult(testFile);
+        EventEmitter.dispatch(["file:start", { result: fileResult }]);
+        this.#runFile(testFilePath, fileResult, position, signal);
+        EventEmitter.dispatch(["file:end", { result: fileResult }]);
+        this.#projectService.closeFile(testFilePath);
+    }
+    #runFile(testFilePath, fileResult, position, signal) {
+        const languageService = this.#projectService.getLanguageService(testFilePath);
+        if (!languageService) {
+            return;
+        }
+        const syntacticDiagnostics = languageService.getSyntacticDiagnostics(testFilePath);
+        if (syntacticDiagnostics.length > 0) {
+            EventEmitter.dispatch([
+                "file:error",
+                {
+                    diagnostics: Diagnostic.fromDiagnostics(syntacticDiagnostics, this.compiler),
+                    result: fileResult,
+                },
+            ]);
+            return;
+        }
+        const semanticDiagnostics = languageService.getSemanticDiagnostics(testFilePath);
+        const program = languageService.getProgram();
+        if (!program) {
+            return;
+        }
+        const sourceFile = program.getSourceFile(testFilePath);
+        if (!sourceFile) {
+            return;
+        }
+        const typeChecker = program.getTypeChecker();
+        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics, typeChecker);
+        if (testTree.diagnostics.length > 0) {
+            EventEmitter.dispatch([
+                "file:error",
+                {
+                    diagnostics: Diagnostic.fromDiagnostics(testTree.diagnostics, this.compiler),
+                    result: fileResult,
+                },
+            ]);
+            return;
+        }
+        const testTreeWorker = new TestTreeWorker(this.resolvedConfig, this.compiler, {
+            fileResult,
+            hasOnly: testTree.hasOnly,
+            position,
+            signal,
+        });
+        testTreeWorker.visit(testTree.members, 0, undefined);
+    }
+}
+
+class TaskRunner {
+    resolvedConfig;
+    #resultManager;
+    #storeService;
+    constructor(resolvedConfig, storeService) {
+        this.resolvedConfig = resolvedConfig;
+        this.#resultManager = new ResultManager();
+        this.#storeService = storeService;
+        EventEmitter.addHandler((event) => {
+            this.#resultManager.handleEvent(event);
+        });
+    }
+    async run(testFiles, target, signal) {
+        const result = new Result(this.resolvedConfig, testFiles);
+        EventEmitter.dispatch(["start", { result }]);
+        for (const versionTag of target) {
+            const targetResult = new TargetResult(versionTag, testFiles);
+            EventEmitter.dispatch(["target:start", { result: targetResult }]);
+            const compiler = await this.#storeService.loadCompilerModule(versionTag, signal);
+            if (compiler) {
+                const testFileRunner = new TestFileRunner(this.resolvedConfig, compiler);
+                for (const testFile of testFiles) {
+                    testFileRunner.run(testFile, signal);
+                }
+            }
+            EventEmitter.dispatch(["target:end", { result: targetResult }]);
+        }
+        EventEmitter.dispatch(["end", { result }]);
+        return result;
+    }
+}
+
+class TSTyche {
+    resolvedConfig;
+    #abortController = new AbortController();
+    #storeService;
+    #taskRunner;
+    constructor(resolvedConfig, storeService) {
+        this.resolvedConfig = resolvedConfig;
+        this.#storeService = storeService;
+        this.#taskRunner = new TaskRunner(this.resolvedConfig, this.#storeService);
+        this.#addEventHandlers();
+    }
+    static get version() {
+        const packageConfig = readFileSync(new URL("../package.json", import.meta.url), { encoding: "utf8" });
+        const { version } = JSON.parse(packageConfig);
+        return version;
+    }
+    #addEventHandlers() {
+        EventEmitter.addHandler(([eventName, payload]) => {
+            if (eventName.includes("error") || eventName.includes("fail")) {
+                if ("diagnostics" in payload &&
+                    !payload.diagnostics.some(({ category }) => category === "error")) {
+                    return;
+                }
+                process.exitCode = 1;
+                if (this.resolvedConfig.failFast) {
+                    this.#abortController.abort();
+                }
+            }
+        });
+        const outputHandlers = [new ThoroughReporter(this.resolvedConfig), new SummaryReporter(this.resolvedConfig)];
+        for (const outputHandler of outputHandlers) {
+            EventEmitter.addHandler((event) => {
+                outputHandler.handleEvent(event);
+            });
+        }
+    }
+    #normalizePaths(testFiles) {
+        return testFiles.map((filePath) => {
+            if (typeof filePath !== "string") {
+                return filePath;
+            }
+            if (filePath.startsWith("file:")) {
+                return new URL(filePath);
+            }
+            return pathToFileURL(filePath);
+        });
+    }
+    async run(testFiles) {
+        await this.#taskRunner.run(this.#normalizePaths(testFiles), this.resolvedConfig.target, this.#abortController.signal);
+    }
+}
+
+class OptionDefinitionsMap {
+    static #definitions = [
+        {
+            brand: "boolean",
+            description: "Do not raise an error, if no test files are selected.",
+            group: 4 | 2,
+            name: "allowNoTestFiles",
+        },
+        {
+            brand: "string",
+            description: "The path to a TSTyche configuration file.",
+            group: 2,
+            name: "config",
+        },
+        {
+            brand: "boolean",
+            description: "Stop running tests after the first failed assertion.",
+            group: 4 | 2,
+            name: "failFast",
+        },
+        {
+            brand: "boolean",
+            description: "Print the list of CLI options with brief descriptions and exit.",
+            group: 2,
+            name: "help",
+        },
+        {
+            brand: "boolean",
+            description: "Install specified versions of the 'typescript' package and exit.",
+            group: 2,
+            name: "install",
+        },
+        {
+            brand: "boolean",
+            description: "Print the list of the selected test files and exit.",
+            group: 2,
+            name: "listFiles",
+        },
+        {
+            brand: "string",
+            description: "Only run tests with matching name.",
+            group: 2,
+            name: "only",
+        },
+        {
+            brand: "boolean",
+            description: "Remove all installed versions of the 'typescript' package and exit.",
+            group: 2,
+            name: "prune",
+        },
+        {
+            brand: "string",
+            description: "The path to a directory containing files of a test project.",
+            group: 4,
+            name: "rootPath",
+        },
+        {
+            brand: "boolean",
+            description: "Print the resolved configuration and exit.",
+            group: 2,
+            name: "showConfig",
+        },
+        {
+            brand: "string",
+            description: "Skip tests with matching name.",
+            group: 2,
+            name: "skip",
+        },
+        {
+            brand: "list",
+            description: "The list of TypeScript versions to be tested on.",
+            group: 2 | 4,
+            items: {
+                brand: "string",
+                name: "target",
+                pattern: "^([45]\\.[0-9](\\.[0-9])?)|beta|latest|next|rc$",
+            },
+            name: "target",
+        },
+        {
+            brand: "list",
+            description: "The list of glob patterns matching the test files.",
+            group: 4,
+            items: {
+                brand: "string",
+                name: "testFileMatch",
+            },
+            name: "testFileMatch",
+        },
+        {
+            brand: "boolean",
+            description: "Fetch the 'typescript' package metadata from the registry and exit.",
+            group: 2,
+            name: "update",
+        },
+        {
+            brand: "boolean",
+            description: "Print the version number and exit.",
+            group: 2,
+            name: "version",
+        },
+    ];
+    static for(optionGroup) {
+        const definitionMap = new Map();
+        for (const definition of this.#definitions) {
+            if (definition.group & optionGroup) {
+                definitionMap.set(definition.name, definition);
+            }
+        }
+        return definitionMap;
+    }
+}
+
+class OptionDiagnosticText {
+    #optionGroup;
+    constructor(optionGroup) {
+        this.#optionGroup = optionGroup;
+    }
+    doubleQuotesExpected() {
+        return "String literal with double quotes expected.";
+    }
+    expectsArgument(optionName) {
+        optionName = this.#optionName(optionName);
+        return `Option '${optionName}' expects an argument.`;
+    }
+    expectsListItemType(optionName, optionBrand) {
+        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
+    }
+    fileDoesNotExist(filePath) {
+        return `The specified path '${filePath}' does not exist.`;
+    }
+    #optionName(optionName) {
+        switch (this.#optionGroup) {
+            case 2:
+                return `--${optionName}`;
+            case 4:
+                return optionName;
+        }
+    }
+    requiresArgumentType(optionName, optionBrand) {
+        optionName = this.#optionName(optionName);
+        return `Option '${optionName}' requires an argument of type ${optionBrand}.`;
+    }
+    unknownOption(optionName) {
+        return `Unknown option '${optionName}'.`;
+    }
+    unknownProperty(optionName) {
+        return `Unknown property '${optionName}'.`;
+    }
+    versionIsNotSupported(value) {
+        return `TypeScript version '${value}' is not supported.`;
+    }
+}
+
+class OptionUsageText {
+    #optionDiagnosticText;
+    #optionGroup;
+    #storeService;
+    constructor(optionGroup, storeService) {
+        this.#optionGroup = optionGroup;
+        this.#optionDiagnosticText = new OptionDiagnosticText(this.#optionGroup);
+        this.#storeService = storeService;
+    }
+    get(optionName, optionBrand) {
+        const usageText = [];
+        switch (optionName) {
+            case "target": {
+                const supportedTags = this.#storeService.getSupportedTags();
+                const supportedTagsText = `Supported tags: ${["'", supportedTags.join("', '"), "'"].join("")}.`;
+                switch (this.#optionGroup) {
+                    case 2:
+                        usageText.push("Argument for the '--target' option must be a single tag or a comma separated list of versions.", "Usage examples: '--target 4.9', '--target 5.0.4', '--target 4.7,4.8,latest'.", supportedTagsText);
+                        break;
+                    case 4:
+                        usageText.push("Item of the 'target' list must be a supported version tag.", supportedTagsText);
+                        break;
+                }
+                break;
+            }
+            default:
+                usageText.push(this.#optionDiagnosticText.requiresArgumentType(optionName, optionBrand));
+        }
+        return usageText;
+    }
+}
+
+class OptionValidator {
+    #onDiagnostic;
+    #optionDiagnosticText;
+    #optionGroup;
+    #optionUsageText;
+    #storeService;
+    constructor(optionGroup, storeService, onDiagnostic) {
+        this.#optionGroup = optionGroup;
+        this.#storeService = storeService;
+        this.#onDiagnostic = onDiagnostic;
+        this.#optionDiagnosticText = new OptionDiagnosticText(this.#optionGroup);
+        this.#optionUsageText = new OptionUsageText(this.#optionGroup, this.#storeService);
+    }
+    check(optionName, optionValue, optionBrand, origin) {
+        switch (optionName) {
+            case "config":
+            case "rootPath":
+                if (!existsSync(optionValue)) {
+                    const text = [this.#optionDiagnosticText.fileDoesNotExist(optionValue)];
+                    this.#onDiagnostic(Diagnostic.error(text, origin));
+                }
+                break;
+            case "target":
+                {
+                    if (!this.#storeService.validateTag(optionValue)) {
+                        this.#onDiagnostic(Diagnostic.error([
+                            this.#optionDiagnosticText.versionIsNotSupported(optionValue),
+                            ...this.#optionUsageText.get(optionName, optionBrand),
+                        ], origin));
+                    }
+                }
+                break;
+        }
+    }
+}
+
+class CommandLineOptionsWorker {
+    #commandLineOptionDefinitions;
+    #commandLineOptions;
+    #onDiagnostic;
+    #optionDiagnosticText;
+    #optionUsageText;
+    #optionValidator;
+    #pathMatch;
+    #storeService;
+    constructor(commandLineOptions, pathMatch, storeService, onDiagnostic) {
+        this.#commandLineOptions = commandLineOptions;
+        this.#pathMatch = pathMatch;
+        this.#storeService = storeService;
+        this.#onDiagnostic = onDiagnostic;
+        this.#commandLineOptionDefinitions = OptionDefinitionsMap.for(2);
+        this.#optionDiagnosticText = new OptionDiagnosticText(2);
+        this.#optionUsageText = new OptionUsageText(2, this.#storeService);
+        this.#optionValidator = new OptionValidator(2, this.#storeService, this.#onDiagnostic);
+    }
+    #normalizePath(filePath) {
+        if (path.sep === "/") {
+            return filePath;
+        }
+        return filePath.replace(/\\/g, "/");
+    }
+    #onExpectsArgumentDiagnostic(optionDefinition) {
+        const text = [
+            this.#optionDiagnosticText.expectsArgument(optionDefinition.name),
+            ...this.#optionUsageText.get(optionDefinition.name, optionDefinition.brand),
+        ];
+        this.#onDiagnostic(Diagnostic.error(text));
+    }
+    parse(commandLineArgs) {
+        let index = 0;
+        let arg = commandLineArgs[index];
+        while (arg !== undefined) {
+            index++;
+            if (arg.startsWith("--")) {
+                const optionName = arg.slice(2);
+                const optionDefinition = this.#commandLineOptionDefinitions.get(optionName);
+                if (optionDefinition) {
+                    index = this.#parseOptionValue(commandLineArgs, index, optionDefinition);
+                }
+                else {
+                    this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.unknownOption(arg)));
+                }
+            }
+            else if (arg.startsWith("-")) {
+                this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.unknownOption(arg)));
+            }
+            else {
+                this.#pathMatch.push(arg);
+            }
+            arg = commandLineArgs[index];
+        }
+    }
+    #parseOptionValue(commandLineArgs, index, optionDefinition) {
+        let optionValue = this.#resolveOptionValue(commandLineArgs[index]);
+        switch (optionDefinition.brand) {
+            case "boolean":
+                this.#commandLineOptions[optionDefinition.name] = optionValue !== "false";
+                if (optionValue === "false" || optionValue === "true") {
+                    index++;
+                }
+                break;
+            case "list":
+                if (optionValue != null) {
+                    const optionValues = optionValue
+                        .split(",")
+                        .map((value) => value.trim())
+                        .filter((value) => value !== "");
+                    for (const optionValue of optionValues) {
+                        this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
+                    }
+                    this.#commandLineOptions[optionDefinition.name] = optionValues;
+                    index++;
+                    break;
+                }
+                this.#onExpectsArgumentDiagnostic(optionDefinition);
+                break;
+            case "number":
+                if (optionValue != null) {
+                    this.#commandLineOptions[optionDefinition.name] = Number(optionValue);
+                    index++;
+                    break;
+                }
+                this.#onExpectsArgumentDiagnostic(optionDefinition);
+                break;
+            case "string":
+                if (optionValue != null) {
+                    if (optionDefinition.name === "config") {
+                        optionValue = this.#normalizePath(path.resolve(optionValue));
+                    }
+                    this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
+                    this.#commandLineOptions[optionDefinition.name] = optionValue;
+                    index++;
+                    break;
+                }
+                this.#onExpectsArgumentDiagnostic(optionDefinition);
+                break;
+        }
+        return index;
+    }
+    #resolveOptionValue(optionValue) {
+        if (optionValue == null || optionValue.startsWith("-")) {
+            return;
+        }
+        return optionValue;
+    }
+}
+
+class ConfigFileOptionsWorker {
+    compiler;
+    #configFileOptionDefinitions;
+    #configFileOptions;
+    #configFilePath;
+    #onDiagnostic;
+    #optionDiagnosticText;
+    #optionValidator;
+    #storeService;
+    constructor(compiler, configFileOptions, configFilePath, storeService, onDiagnostic) {
+        this.compiler = compiler;
+        this.#configFileOptions = configFileOptions;
+        this.#configFilePath = configFilePath;
+        this.#storeService = storeService;
+        this.#onDiagnostic = onDiagnostic;
+        this.#configFileOptionDefinitions = OptionDefinitionsMap.for(4);
+        this.#optionDiagnosticText = new OptionDiagnosticText(4);
+        this.#optionValidator = new OptionValidator(4, this.#storeService, this.#onDiagnostic);
+    }
+    #isDoubleQuotedString(node, sourceFile) {
+        return (node.kind === this.compiler.SyntaxKind.StringLiteral &&
+            sourceFile.text.slice(this.#skipTrivia(node.pos, sourceFile), node.end).startsWith('"'));
+    }
+    #normalizePath(filePath) {
+        if (path.sep === "/") {
+            return filePath;
+        }
+        return filePath.replace(/\\/g, "/");
+    }
+    async parse(sourceText) {
+        if (sourceText === "") {
+            return;
+        }
+        const configSourceFile = this.compiler.parseJsonText(this.#configFilePath, sourceText);
+        if (configSourceFile.parseDiagnostics.length > 0) {
+            for (const diagnostic of Diagnostic.fromDiagnostics(configSourceFile.parseDiagnostics, this.compiler)) {
+                this.#onDiagnostic(diagnostic);
+            }
+            return;
+        }
+        const rootExpression = configSourceFile.statements[0]?.expression;
+        if (rootExpression == null || !this.compiler.isObjectLiteralExpression(rootExpression)) {
+            const origin = { end: 0, file: configSourceFile, start: 0 };
+            this.#onDiagnostic(Diagnostic.error("The root value of a configuration file must be an object literal.", origin));
+            return;
+        }
+        for (const property of rootExpression.properties) {
+            if (this.compiler.isPropertyAssignment(property)) {
+                if (!this.#isDoubleQuotedString(property.name, configSourceFile)) {
+                    const origin = {
+                        end: property.end,
+                        file: configSourceFile,
+                        start: this.#skipTrivia(property.pos, configSourceFile),
+                    };
+                    this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.doubleQuotesExpected(), origin));
+                    continue;
+                }
+                const optionName = this.#resolvePropertyName(property);
+                if (optionName === "$schema") {
+                    continue;
+                }
+                const optionDefinition = this.#configFileOptionDefinitions.get(optionName);
+                if (optionDefinition) {
+                    this.#configFileOptions[optionDefinition.name] = await this.#parseOptionValue(configSourceFile, property.initializer, optionDefinition);
+                }
+                else {
+                    const origin = {
+                        end: property.end,
+                        file: configSourceFile,
+                        start: this.#skipTrivia(property.pos, configSourceFile),
+                    };
+                    this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.unknownOption(optionName), origin));
+                }
+            }
+        }
+        return;
+    }
+    async #parseOptionValue(sourceFile, valueExpression, optionDefinition, isListItem = false) {
+        switch (valueExpression.kind) {
+            case this.compiler.SyntaxKind.NullKeyword:
+                if (optionDefinition.nullable === true) {
+                    return null;
+                }
+                break;
+            case this.compiler.SyntaxKind.TrueKeyword:
+                if (optionDefinition.brand === "boolean") {
+                    return true;
+                }
+                break;
+            case this.compiler.SyntaxKind.FalseKeyword:
+                if (optionDefinition.brand === "boolean") {
+                    return false;
+                }
+                break;
+            case this.compiler.SyntaxKind.StringLiteral:
+                if (!this.#isDoubleQuotedString(valueExpression, sourceFile)) {
+                    const origin = {
+                        end: valueExpression.end,
+                        file: sourceFile,
+                        start: this.#skipTrivia(valueExpression.pos, sourceFile),
+                    };
+                    this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.doubleQuotesExpected(), origin));
+                    return;
+                }
+                if (optionDefinition.brand === "string") {
+                    let value = valueExpression.text;
+                    if (optionDefinition.name === "rootPath") {
+                        value = this.#normalizePath(path.resolve(path.dirname(this.#configFilePath), value));
+                    }
+                    const origin = {
+                        end: valueExpression.end,
+                        file: sourceFile,
+                        start: this.#skipTrivia(valueExpression.pos, sourceFile),
+                    };
+                    this.#optionValidator.check(optionDefinition.name, value, optionDefinition.brand, origin);
+                    return value;
+                }
+                break;
+            case this.compiler.SyntaxKind.NumericLiteral:
+                if (optionDefinition.brand === "number") {
+                    return Number(valueExpression.text);
+                }
+                break;
+            case this.compiler.SyntaxKind.ArrayLiteralExpression:
+                if (optionDefinition.brand === "list") {
+                    const value = [];
+                    for (const element of valueExpression.elements) {
+                        value.push(await this.#parseOptionValue(sourceFile, element, optionDefinition.items, true));
+                    }
+                    return value;
+                }
+                break;
+            case this.compiler.SyntaxKind.ObjectLiteralExpression:
+                if (optionDefinition.brand === "object" && "getDefinition" in optionDefinition) {
+                    const propertyDefinition = optionDefinition.getDefinition(4);
+                    const propertyOptions = {};
+                    for (const property of valueExpression.properties) {
+                        if (this.compiler.isPropertyAssignment(property)) {
+                            if (!this.#isDoubleQuotedString(property.name, sourceFile)) {
+                                const origin = {
+                                    end: property.end,
+                                    file: sourceFile,
+                                    start: this.#skipTrivia(property.pos, sourceFile),
+                                };
+                                this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.doubleQuotesExpected(), origin));
+                                continue;
+                            }
+                            const optionName = this.#resolvePropertyName(property);
+                            const optionDefinition = propertyDefinition.get(optionName);
+                            if (optionDefinition) {
+                                propertyOptions[optionDefinition.name] = await this.#parseOptionValue(sourceFile, property.initializer, optionDefinition);
+                            }
+                            else {
+                                const origin = {
+                                    end: property.end,
+                                    file: sourceFile,
+                                    start: this.#skipTrivia(property.pos, sourceFile),
+                                };
+                                this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.unknownProperty(optionName), origin));
+                            }
+                        }
+                    }
+                    return propertyOptions;
+                }
+                break;
+        }
+        const origin = {
+            end: valueExpression.end,
+            file: sourceFile,
+            start: this.#skipTrivia(valueExpression.pos, sourceFile),
+        };
+        const text = isListItem
+            ? this.#optionDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
+            : this.#optionDiagnosticText.requiresArgumentType(optionDefinition.name, optionDefinition.brand);
+        this.#onDiagnostic(Diagnostic.error(text, origin));
+        return;
+    }
+    #resolvePropertyName({ name }) {
+        if ("text" in name) {
+            return name.text;
+        }
+        return "";
+    }
+    #skipTrivia(position, sourceFile) {
+        const { text } = sourceFile.getSourceFile();
+        while (position < text.length) {
+            if (/\s/.test(text.charAt(position))) {
+                position++;
+                continue;
+            }
+            else if (text.charAt(position) === "/") {
+                if (text.charAt(position + 1) === "/") {
+                    position += 2;
+                    while (position < text.length) {
+                        if (text.charAt(position) === "\n") {
+                            break;
+                        }
+                        position++;
+                    }
+                    continue;
+                }
+                if (text.charAt(position + 1) === "*") {
+                    position += 2;
+                    while (position < text.length) {
+                        if (text.charAt(position) === "*" && text.charAt(position + 1) === "/") {
+                            position += 2;
+                            break;
+                        }
+                        position++;
+                    }
+                    continue;
+                }
+                position++;
+                continue;
+            }
+            break;
+        }
+        return position;
+    }
+}
+
+class ConfigService {
+    compiler;
+    #commandLineOptions = {};
+    #configFileOptions = {};
+    static #defaultOptions = {
+        allowNoTestFiles: false,
+        failFast: false,
+        rootPath: "./",
+        target: ["latest"],
+        testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
+    };
+    #pathMatch = [];
+    #storeService;
+    constructor(compiler, storeService) {
+        this.compiler = compiler;
+        this.#storeService = storeService;
+    }
+    get commandLineOptions() {
+        return this.#commandLineOptions;
+    }
+    get configFileOptions() {
+        return this.#configFileOptions;
+    }
+    static get defaultOptions() {
+        return ConfigService.#defaultOptions;
+    }
+    #normalizePath(filePath) {
+        if (path.sep === "/") {
+            return filePath;
+        }
+        return filePath.replace(/\\/g, "/");
+    }
+    #onDiagnostic = (diagnostic) => {
+        EventEmitter.dispatch(["config:error", { diagnostics: [diagnostic] }]);
+    };
+    parseCommandLine(commandLineArgs) {
+        this.#commandLineOptions = {};
+        this.#pathMatch = [];
+        const commandLineWorker = new CommandLineOptionsWorker(this.#commandLineOptions, this.#pathMatch, this.#storeService, this.#onDiagnostic);
+        commandLineWorker.parse(commandLineArgs);
+    }
+    async readConfigFile(filePath, sourceText) {
+        const configFilePath = filePath ?? this.#commandLineOptions.config ?? path.resolve("./tstyche.config.json");
+        this.#configFileOptions = {
+            rootPath: this.#normalizePath(path.dirname(configFilePath)),
+        };
+        let configFileText = sourceText ?? "";
+        if (sourceText == null && existsSync(configFilePath)) {
+            configFileText = await fs.readFile(configFilePath, {
+                encoding: "utf8",
+            });
+        }
+        const configFileWorker = new ConfigFileOptionsWorker(this.compiler, this.#configFileOptions, configFilePath, this.#storeService, this.#onDiagnostic);
+        await configFileWorker.parse(configFileText);
+    }
+    resolveConfig() {
+        const mergedOptions = {
+            ...ConfigService.#defaultOptions,
+            ...this.#configFileOptions,
+            ...this.#commandLineOptions,
+            pathMatch: this.#pathMatch.map((match) => this.#normalizePath(match)),
+        };
+        return mergedOptions;
+    }
+    selectTestFiles() {
+        const { allowNoTestFiles, pathMatch, rootPath, testFileMatch } = this.resolveConfig();
+        let testFilePaths = this.compiler.sys.readDirectory(rootPath, undefined, undefined, testFileMatch);
+        if (pathMatch.length > 0) {
+            testFilePaths = testFilePaths.filter((testFilePath) => pathMatch.some((match) => {
+                const relativeTestFilePath = this.#normalizePath(`./${path.relative("", testFilePath)}`);
+                return relativeTestFilePath.toLowerCase().includes(match.toLowerCase());
+            }));
+        }
+        if (testFilePaths.length === 0 && !allowNoTestFiles) {
+            const text = [
+                "No test files were selected using current configuration.",
+                `Root path:       ${rootPath}`,
+                `Test file match: ${testFileMatch.join(", ")}`,
+            ];
+            if (pathMatch.length > 0) {
+                text.push(`Path match:      ${pathMatch.join(", ")}`);
+            }
+            this.#onDiagnostic(Diagnostic.error(text));
+        }
+        return testFilePaths;
+    }
+}
+
+var OptionBrand;
+(function (OptionBrand) {
+    OptionBrand["String"] = "string";
+    OptionBrand["Number"] = "number";
+    OptionBrand["Boolean"] = "boolean";
+    OptionBrand["List"] = "list";
+    OptionBrand["Object"] = "object";
+})(OptionBrand || (OptionBrand = {}));
+
+var OptionGroup;
+(function (OptionGroup) {
+    OptionGroup[OptionGroup["CommandLine"] = 2] = "CommandLine";
+    OptionGroup[OptionGroup["ConfigFile"] = 4] = "ConfigFile";
+})(OptionGroup || (OptionGroup = {}));
+
+class Lock {
+    #lockFilePath;
+    static #lockSuffix = "__lock__";
+    constructor(targetPath) {
+        this.#lockFilePath = Lock.getLockFilePath(targetPath);
+        writeFileSync(this.#lockFilePath, "");
+        process.on("exit", () => {
+            this.release();
+        });
+    }
+    static getLockFilePath(targetPath) {
+        return `${targetPath}${Lock.#lockSuffix}`;
+    }
+    static isLocked(targetPath) {
+        return existsSync(Lock.getLockFilePath(targetPath));
+    }
+    release() {
+        rmSync(this.#lockFilePath, { force: true });
+    }
+}
+
+class CompilerModuleWorker {
+    #cachePath;
+    #readyFileName = "__ready__";
+    #timeout = Environment.timeout * 1000;
+    constructor(cachePath) {
+        this.#cachePath = cachePath;
+    }
+    async ensure(compilerVersion, signal) {
+        const installationPath = path.join(this.#cachePath, compilerVersion);
+        const readyFilePath = path.join(installationPath, this.#readyFileName);
+        const tsserverFilePath = path.join(installationPath, "node_modules", "typescript", "lib", "tsserverlibrary.js");
+        const typescriptFilePath = path.join(installationPath, "node_modules", "typescript", "lib", "typescript.js");
+        if (Lock.isLocked(installationPath)) {
+            for await (const now of setInterval(1000, Date.now(), { signal })) {
+                const startTime = Date.now();
+                if (!Lock.isLocked(installationPath)) {
+                    break;
+                }
+                if (startTime - now > this.#timeout) {
+                    throw new Error(`Lock wait timeout of ${this.#timeout / 1000}s was exceeded.`);
+                }
+            }
+        }
+        if (existsSync(readyFilePath)) {
+            return tsserverFilePath;
+        }
+        EventEmitter.dispatch(["store:info", { compilerVersion, installationPath }]);
+        await fs.mkdir(installationPath, { recursive: true });
+        const lock = new Lock(installationPath);
+        await fs.writeFile(path.join(installationPath, "package.json"), this.#getPackageJson(compilerVersion));
+        await this.#installPackage(installationPath, signal);
+        await fs.writeFile(tsserverFilePath, await this.#getPatched(compilerVersion, tsserverFilePath));
+        await fs.writeFile(typescriptFilePath, await this.#getPatched(compilerVersion, typescriptFilePath));
+        await fs.writeFile(readyFilePath, "");
+        lock.release();
+        return tsserverFilePath;
+    }
+    #getPackageJson(version) {
+        const packageJson = {
+            name: "@tstyche/typescript",
+            version,
+            description: "Do not change. This package was generated by TSTyche",
+            private: true,
+            license: "MIT",
+            dependencies: {
+                typescript: version,
+            },
+        };
+        return JSON.stringify(packageJson, null, 2);
+    }
+    async #getPatched(version, filePath) {
+        function ts5Patch(match, indent) {
+            return [match, indent, "isTypeIdenticalTo,", indent, "isTypeSubtypeOf,"].join("");
+        }
+        function ts4Patch(match, indent) {
+            return [match, indent, "isTypeIdenticalTo: isTypeIdenticalTo,", indent, "isTypeSubtypeOf: isTypeSubtypeOf,"].join("");
+        }
+        const fileContent = await fs.readFile(filePath, { encoding: "utf8" });
+        if (version.startsWith("5")) {
+            return fileContent.replace(/(\s+)isTypeAssignableTo,/, ts5Patch);
+        }
+        else {
+            return fileContent.replace(/(\s+)isTypeAssignableTo: isTypeAssignableTo,/, ts4Patch);
+        }
+    }
+    async #installPackage(cwd, signal) {
+        const args = ["install", "--ignore-scripts", "--no-bin-links", "--no-package-lock"];
+        return new Promise((resolve, reject) => {
+            const spawnedNpm = spawn("npm", args, {
+                cwd,
+                shell: true,
+                signal,
+                stdio: "ignore",
+                timeout: this.#timeout,
+            });
+            spawnedNpm.on("error", (error) => {
+                reject(error);
+            });
+            spawnedNpm.on("close", (code, signal) => {
+                if (code === 0) {
+                    resolve();
+                }
+                if (signal != null) {
+                    reject(new Error(`Setup timeout of ${this.#timeout / 1000}s was exceeded.`));
+                }
+                reject(new Error(`Process exited with code ${String(code)}.`));
+            });
+        });
+    }
+}
+
+class ManifestWorker {
+    #cachePath;
+    #manifestFileName = "store-manifest.json";
+    #manifestFilePath;
+    #prune;
+    #registryUrl = new URL("https://registry.npmjs.org");
+    #timeout = Environment.timeout * 1000;
+    constructor(cachePath, prune) {
+        this.#cachePath = cachePath;
+        this.#manifestFilePath = path.join(cachePath, this.#manifestFileName);
+        this.#prune = prune;
+    }
+    async #fetch(signal) {
+        return new Promise((resolve, reject) => {
+            const request = https.get(new URL("typescript", this.#registryUrl), {
+                headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*" },
+                signal,
+            }, (result) => {
+                if (result.statusCode !== 200) {
+                    reject(new Error(`Request failed with status code ${String(result.statusCode)}.`));
+                    return;
+                }
+                result.setEncoding("utf8");
+                let rawData = "";
+                result.on("data", (chunk) => {
+                    rawData += chunk;
+                });
+                result.on("end", () => {
+                    try {
+                        const packageMetadata = JSON.parse(rawData);
+                        resolve(packageMetadata);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+            request.on("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    isOutdated(manifest, ageTolerance = 0) {
+        if (Date.now() - manifest.lastUpdated > 2 * 60 * 60 * 1000 + ageTolerance * 1000) {
+            return true;
+        }
+        return false;
+    }
+    async #load(signal, isUpdate = false) {
+        const manifest = {
+            lastUpdated: Date.now(),
+            resolutions: {},
+            versions: [],
+        };
+        let packageMetadata;
+        const abortController = new AbortController();
+        const timeoutSignal = AbortSignal.timeout(this.#timeout);
+        timeoutSignal.addEventListener("abort", () => {
+            abortController.abort(`Setup timeout of ${this.#timeout / 1000}s was exceeded.`);
+        }, { once: true });
+        signal?.addEventListener("abort", () => {
+            abortController.abort(`Fetch got canceled by request.`);
+        }, { once: true });
+        try {
+            packageMetadata = await this.#fetch(abortController.signal);
+        }
+        catch (error) {
+            if (!isUpdate) {
+                const text = [`Failed to fetch metadata of the 'typescript' package from '${this.#registryUrl.href}'.`];
+                if (error instanceof Error && error.name !== "AbortError") {
+                    text.push("Might be there is an issue with the registry or the network connection.");
+                }
+                this.#onDiagnostic(Diagnostic.fromError(text, error));
+            }
+        }
+        if (!packageMetadata) {
+            return;
+        }
+        manifest.versions = Object.keys(packageMetadata.versions)
+            .filter((version) => /^(4|5)\.\d\.\d$/.test(version))
+            .sort();
+        const minorVersions = [...new Set(manifest.versions.map((version) => version.slice(0, -2)))];
+        for (const tag of minorVersions) {
+            const resolvedVersion = manifest.versions.filter((version) => version.startsWith(tag)).pop();
+            if (resolvedVersion != null) {
+                manifest.resolutions[tag] = resolvedVersion;
+            }
+        }
+        for (const distributionTagKey of ["beta", "latest", "next", "rc"]) {
+            const distributionTagValue = packageMetadata["dist-tags"][distributionTagKey];
+            if (distributionTagValue != null) {
+                manifest.resolutions[distributionTagKey] = distributionTagValue;
+            }
+        }
+        return manifest;
+    }
+    #onDiagnostic(diagnostic) {
+        EventEmitter.dispatch(["store:error", { diagnostics: [diagnostic] }]);
+    }
+    async open(signal) {
+        let manifest;
+        if (!existsSync(this.#manifestFilePath)) {
+            manifest = await this.#load(signal);
+            if (manifest == null) {
+                return;
+            }
+            await this.persist(manifest);
+            return manifest;
+        }
+        let manifestText;
+        try {
+            manifestText = await fs.readFile(this.#manifestFilePath, { encoding: "utf8" });
+        }
+        catch (error) {
+            this.#onDiagnostic(Diagnostic.fromError("Failed to open store manifest.", error));
+        }
+        if (manifestText == null) {
+            return;
+        }
+        try {
+            manifest = JSON.parse(manifestText);
+        }
+        catch (error) {
+            this.#onDiagnostic(Diagnostic.fromError([
+                `Failed to parse '${this.#manifestFilePath}'.`,
+                "Cached files appeared to be corrupt and got removed. Try running 'tstyche' again.",
+            ], error));
+        }
+        if (manifest == null) {
+            await this.#prune();
+            return;
+        }
+        if (this.isOutdated(manifest)) {
+            manifest = await this.update(manifest, signal);
+        }
+        return manifest;
+    }
+    async persist(manifest) {
+        if (!existsSync(this.#cachePath)) {
+            await fs.mkdir(this.#cachePath, { recursive: true });
+        }
+        await fs.writeFile(this.#manifestFilePath, JSON.stringify(manifest));
+    }
+    async update(manifest, signal) {
+        const freshManifest = await this.#load(signal, true);
+        if (freshManifest != null) {
+            manifest = { ...manifest, ...freshManifest };
+            await this.persist(manifest);
+        }
+        return manifest;
+    }
+}
+
+class StoreService {
+    #cachePath;
+    #compilerModuleWorker;
+    #manifest;
+    #manifestWorker;
+    #nodeRequire = createRequire(import.meta.url);
+    constructor() {
+        this.#cachePath = Environment.storePath;
+        this.#compilerModuleWorker = new CompilerModuleWorker(this.#cachePath);
+        this.#manifestWorker = new ManifestWorker(this.#cachePath, async () => this.prune());
+    }
+    getSupportedTags() {
+        if (!this.#manifest) {
+            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
+            return [];
+        }
+        return [...Object.keys(this.#manifest.resolutions), ...this.#manifest.versions].sort();
+    }
+    async loadCompilerModule(tag, signal) {
+        let modulePath;
+        if (tag === "local") {
+            try {
+                modulePath = this.#nodeRequire.resolve("typescript/lib/tsserverlibrary.js");
+            }
+            catch {
+                tag = "latest";
+            }
+        }
+        if (modulePath == null) {
+            modulePath = await this.prepareCompilerModule(tag, signal);
+        }
+        if (modulePath != null) {
+            return this.#nodeRequire(modulePath);
+        }
+        return;
+    }
+    #onDiagnostic(diagnostic) {
+        EventEmitter.dispatch(["store:error", { diagnostics: [diagnostic] }]);
+    }
+    async open(signal) {
+        if (this.#manifest) {
+            return;
+        }
+        this.#manifest = await this.#manifestWorker.open(signal);
+    }
+    async prepareCompilerModule(tag, signal) {
+        if (!this.#manifest) {
+            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
+            return;
+        }
+        const version = this.resolveTag(tag);
+        if (version == null) {
+            this.#onDiagnostic(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
+            return;
+        }
+        let modulePath;
+        try {
+            modulePath = await this.#compilerModuleWorker.ensure(version, signal);
+        }
+        catch (error) {
+            this.#onDiagnostic(Diagnostic.fromError(`Failed to install 'typescript@${version}'.`, error));
+        }
+        if (modulePath != null) {
+            if (!("lastUsed" in this.#manifest)) {
+                this.#manifest.lastUsed = {};
+            }
+            this.#manifest.lastUsed[version] = Date.now();
+        }
+        return modulePath;
+    }
+    async prune() {
+        await fs.rm(this.#cachePath, { force: true, recursive: true });
+    }
+    resolveTag(tag) {
+        if (!this.#manifest) {
+            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
+            return;
+        }
+        if (this.#manifest.versions.includes(tag)) {
+            return tag;
+        }
+        const version = this.#manifest.resolutions[tag];
+        if (this.#manifestWorker.isOutdated(this.#manifest, 60) &&
+            Object.keys(this.#manifest.resolutions).slice(-5).includes(tag)) {
+            this.#onDiagnostic(Diagnostic.warning([
+                "Failed to update metadata of the 'typescript' package from the registry.",
+                `The resolution of the '${tag}' tag may be outdated.`,
+            ]));
+        }
+        return version;
+    }
+    async update(signal) {
+        if (!this.#manifest) {
+            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
+            return;
+        }
+        await this.#manifestWorker.update(this.#manifest, signal);
+    }
+    validateTag(tag) {
+        if (!this.#manifest) {
+            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
+            return false;
+        }
+        if (this.#manifest.versions.includes(tag) || tag in this.#manifest.resolutions) {
+            return true;
+        }
+        if (this.#manifest.resolutions["latest"] != null &&
+            tag.startsWith(this.#manifest.resolutions["latest"].slice(0, 3))) {
+            this.#onDiagnostic(Diagnostic.warning([
+                "Failed to update metadata of the 'typescript' package from the registry.",
+                `The resolution of the '${tag}' tag may be outdated.`,
+            ]));
+        }
+        return false;
+    }
+}
+
+class JsonText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Line, null, JSON.stringify(this.#sortObject(this.props.input), null, 2));
+    }
+    #sortObject(target) {
+        if (Array.isArray(target)) {
+            return target;
+        }
+        return Object.keys(target)
+            .sort()
+            .reduce((result, key) => {
+            result[key] = target[key];
+            return result;
+        }, {});
+    }
+}
+function formattedText(input) {
+    if (typeof input === "string") {
+        return Scribbler.createElement(Line, null, input);
+    }
+    return Scribbler.createElement(JsonText, { input: input });
+}
+
+const usageExamples = [
+    ["tstyche", "Run all tests."],
+    ["tstyche path/to/first.test.ts second", "Only run the test files with matching path."],
+    ["tstyche --target 4.7,4.8,latest", "Test on all specified versions of TypeScript."],
+];
+class HintText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return (Scribbler.createElement(Text, { indent: 1, color: "90" }, this.props.children));
+    }
+}
+class HelpHeaderText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const hint = (Scribbler.createElement(HintText, null,
+            Scribbler.createElement(Text, null, this.props.tstycheVersion)));
+        return (Scribbler.createElement(Line, null,
+            Scribbler.createElement(Text, null, "The TSTyche Type Test Runner"),
+            hint));
+    }
+}
+class CommandText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        let hint = undefined;
+        if (this.props.hint != null) {
+            hint = Scribbler.createElement(HintText, null, this.props.hint);
+        }
+        return (Scribbler.createElement(Line, { indent: 1 },
+            Scribbler.createElement(Text, { color: "34" }, this.props.text),
+            hint));
+    }
+}
+class OptionDescriptionText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Line, { indent: 1 }, this.props.text);
+    }
+}
+class CliUsageText {
+    render() {
+        const usageText = usageExamples.map(([commandText, descriptionText]) => (Scribbler.createElement(Text, null,
+            Scribbler.createElement(CommandText, { text: commandText }),
+            Scribbler.createElement(OptionDescriptionText, { text: descriptionText }),
+            Scribbler.createElement(Line, null))));
+        return Scribbler.createElement(Text, null, usageText);
+    }
+}
+class OptionNameText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Text, null,
+            "--",
+            this.props.text);
+    }
+}
+class OptionHintText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        if (this.props.definition.brand === "list") {
+            return (Scribbler.createElement(Text, null,
+                this.props.definition.brand,
+                " of ",
+                this.props.definition.items.brand,
+                "s"));
+        }
+        return Scribbler.createElement(Text, null, this.props.definition.brand);
+    }
+}
+class CliOptionsText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const definitions = Array.from(this.props.optionDefinitions.values());
+        const optionsText = definitions.map((definition) => (Scribbler.createElement(Text, null,
+            Scribbler.createElement(CommandText, { text: Scribbler.createElement(OptionNameText, { text: definition.name }), hint: Scribbler.createElement(OptionHintText, { definition: definition }) }),
+            Scribbler.createElement(OptionDescriptionText, { text: definition.description }),
+            Scribbler.createElement(Line, null))));
+        return (Scribbler.createElement(Text, null,
+            Scribbler.createElement(Line, null, "CLI Options"),
+            Scribbler.createElement(Line, null),
+            optionsText));
+    }
+}
+class HelpFooterText {
+    render() {
+        return Scribbler.createElement(Line, null, "To learn more, visit https://tstyche.org");
+    }
+}
+function helpText(optionDefinitions, tstycheVersion) {
+    return (Scribbler.createElement(Text, null,
+        Scribbler.createElement(HelpHeaderText, { tstycheVersion: tstycheVersion }),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(CliUsageText, null),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(CliOptionsText, { optionDefinitions: optionDefinitions }),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(HelpFooterText, null),
+        Scribbler.createElement(Line, null)));
+}
+
+class Cli {
+    #abortController = new AbortController();
+    #logger;
+    #process;
+    #storeService;
+    constructor(process) {
+        this.#process = process;
+        this.#logger = new Logger();
+        this.#storeService = new StoreService();
+    }
+    #onStartupEvent = ([eventName, payload]) => {
+        switch (eventName) {
+            case "store:info":
+                this.#logger.writeMessage(addsPackageStepText(payload.compilerVersion, payload.installationPath));
+                break;
+            case "config:error":
+            case "store:error":
+                for (const diagnostic of payload.diagnostics) {
+                    switch (diagnostic.category) {
+                        case "error":
+                            this.#abortController.abort();
+                            this.#process.exitCode = 1;
+                            this.#logger.writeError(diagnosticText(diagnostic));
+                            break;
+                        case "warning":
+                            this.#logger.writeWarning(diagnosticText(diagnostic));
+                            break;
+                    }
+                }
+                break;
+        }
+    };
+    async run(commandLineArgs) {
+        EventEmitter.addHandler(this.#onStartupEvent);
+        await this.#storeService.open(this.#abortController.signal);
+        if (this.#process.exitCode === 1) {
+            return;
+        }
+        const compiler = await this.#storeService.loadCompilerModule("local", this.#abortController.signal);
+        if (!compiler) {
+            return;
+        }
+        const configService = new ConfigService(compiler, this.#storeService);
+        configService.parseCommandLine(commandLineArgs);
+        if (this.#process.exitCode === 1) {
+            return;
+        }
+        if (configService.commandLineOptions.prune === true) {
+            await this.#storeService.prune();
+            return;
+        }
+        if (configService.commandLineOptions.help === true) {
+            const commandLineOptionDefinitions = OptionDefinitionsMap.for(2);
+            this.#logger.writeMessage(helpText(commandLineOptionDefinitions, TSTyche.version));
+            return;
+        }
+        if (configService.commandLineOptions.update === true) {
+            await this.#storeService.update();
+            return;
+        }
+        if (configService.commandLineOptions.version === true) {
+            this.#logger.writeMessage(formattedText(TSTyche.version));
+            return;
+        }
+        await configService.readConfigFile();
+        if (this.#process.exitCode === 1) {
+            return;
+        }
+        const resolvedConfig = configService.resolveConfig();
+        if (configService.commandLineOptions.showConfig === true) {
+            this.#logger.writeMessage(formattedText({
+                noColor: Environment.noColor,
+                storePath: Environment.storePath,
+                timeout: Environment.timeout,
+                ...resolvedConfig,
+            }));
+            return;
+        }
+        if (configService.commandLineOptions.install === true) {
+            for (const tag of resolvedConfig.target) {
+                await this.#storeService.prepareCompilerModule(tag, this.#abortController.signal);
+            }
+            return;
+        }
+        const testFiles = configService.selectTestFiles();
+        if (this.#process.exitCode === 1) {
+            return;
+        }
+        if (configService.commandLineOptions.listFiles === true) {
+            this.#logger.writeMessage(formattedText(testFiles));
+            return;
+        }
+        EventEmitter.removeHandler(this.#onStartupEvent);
+        const tstyche = new TSTyche(resolvedConfig, this.#storeService);
+        await tstyche.run(testFiles);
+    }
+}
+
+export { Assertion, AssertionSource, Checker, Cli, CollectService, Color, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, ExpectResult, FileResult, Line, Logger, OptionBrand, OptionDefinitionsMap, OptionGroup, ProjectResult, ProjectService, Reporter, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, ThoroughReporter, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, summaryText, testNameText, usesCompilerStepText };