tstyche 4.0.0 → 4.0.2

package/build/tstyche.d.ts

@@ -20,153 +20,37 @@ declare class Cli {
     run(commandLine: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
-declare enum OptionBrand {
-    String = "string",
-    Number = "number",
-    Boolean = "boolean",
-    BareTrue = "bareTrue",// a boolean option that does not take a value and when specified is interpreted as 'true'
-    List = "list"
-}
-
-declare class ConfigDiagnosticText {
-    static expected(element: string): string;
-    static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
-    static expectsValue(optionName: string): string;
-    static fileDoesNotExist(filePath: string): string;
-    static inspectSupportedVersions(): string;
-    static moduleWasNotFound(specifier: string): string;
-    static rangeIsNotValid(value: string): string;
-    static rangeUsage(): Array<string>;
-    static requiresValueType(optionName: string, optionBrand: OptionBrand): string;
-    static seen(element: string): string;
-    static testFileMatchCannotStartWith(segment: string): Array<string>;
-    static unexpected(element: string): string;
-    static unknownOption(optionName: string): string;
-    static usage(optionName: string, optionBrand: OptionBrand): Array<string>;
-    static versionIsNotSupported(value: string): string;
-    static watchCannotBeEnabled(): string;
-}
-
-/**
- * Options passed through the command line.
- */
 interface CommandLineOptions {
-    /**
-     * The path to a TSTyche configuration file.
-     */
     config?: string;
-    /**
-     * Stop running tests after the first failed assertion.
-     */
     failFast?: boolean;
-    /**
-     * Fetch the specified versions of the 'typescript' package and exit.
-     */
     fetch?: boolean;
-    /**
-     * Print the list of command line options with brief descriptions and exit.
-     */
     help?: boolean;
-    /**
-     * Print the list of supported versions of the 'typescript' package and exit.
-     */
     list?: boolean;
-    /**
-     * Print the list of the selected test files and exit.
-     */
     listFiles?: boolean;
-    /**
-     * Only run tests with matching name.
-     */
     only?: string;
-    /**
-     * The list of plugins to use.
-     */
     plugins?: Array<string>;
-    /**
-     * Remove all installed versions of the 'typescript' package and exit.
-     */
     prune?: boolean;
-    /**
-     * The list of reporters to use.
-     */
     reporters?: Array<string>;
-    /**
-     * Print the resolved configuration and exit.
-     */
     showConfig?: boolean;
-    /**
-     * Skip tests with matching name.
-     */
     skip?: string;
-    /**
-     * The list of TypeScript versions to be tested on.
-     */
     target?: Array<string>;
-    /**
-     * The look up strategy to be used to find the TSConfig file.
-     */
     tsconfig?: string;
-    /**
-     * Fetch the 'typescript' package metadata from the registry and exit.
-     */
     update?: boolean;
-    /**
-     * Print the version number and exit.
-     */
     version?: boolean;
-    /**
-     * Watch for changes and rerun related test files.
-     */
     watch?: boolean;
 }
-
-/**
- * Options loaded from the configuration file.
- */
 interface ConfigFileOptions {
-    /**
-     * Enable type error reporting for source files.
-     */
     checkSourceFiles?: boolean;
-    /**
-     * Stop running tests after the first failed assertion.
-     */
     failFast?: boolean;
-    /**
-     * The list of plugins to use.
-     */
     plugins?: Array<string>;
-    /**
-     * Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.
-     */
     rejectAnyType?: boolean;
-    /**
-     * Reject the 'never' type passed as an argument to the 'expect()' function or a matcher.
-     */
     rejectNeverType?: boolean;
-    /**
-     * The list of reporters to use.
-     */
     reporters?: Array<string>;
-    /**
-     * The path to a directory containing files of a test project.
-     */
     rootPath?: string;
-    /**
-     * The list of TypeScript versions to be tested on.
-     */
     target?: Array<string>;
-    /**
-     * The list of glob patterns matching the test files.
-     */
     testFileMatch?: Array<string>;
-    /**
-     * The look up strategy to be used to find the TSConfig file.
-     */
     tsconfig?: string;
 }
-
 interface InlineConfig {
     if?: {
         target?: Array<string>;
@@ -174,13 +58,7 @@ interface InlineConfig {
     template?: boolean;
 }
 interface ResolvedConfig extends Omit<CommandLineOptions, "config" | keyof ConfigFileOptions>, Required<ConfigFileOptions> {
-    /**
-     * The path to a TSTyche configuration file.
-     */
     configFilePath: string;
-    /**
-     * Only run test files with matching path.
-     */
     pathMatch: Array<string>;
 }
 
@@ -203,6 +81,33 @@ declare class Config {
     static resolveConfigFilePath(filePath?: string): string;
 }
 
+declare enum OptionBrand {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    BareTrue = "bareTrue",
+    List = "list"
+}
+
+declare class ConfigDiagnosticText {
+    static expected(element: string): string;
+    static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
+    static expectsValue(optionName: string): string;
+    static fileDoesNotExist(filePath: string): string;
+    static inspectSupportedVersions(): string;
+    static moduleWasNotFound(specifier: string): string;
+    static rangeIsNotValid(value: string): string;
+    static rangeUsage(): Array<string>;
+    static requiresValueType(optionName: string, optionBrand: OptionBrand): string;
+    static seen(element: string): string;
+    static testFileMatchCannotStartWith(segment: string): Array<string>;
+    static unexpected(element: string): string;
+    static unknownOption(optionName: string): string;
+    static usage(optionName: string, optionBrand: OptionBrand): Array<string>;
+    static versionIsNotSupported(value: string): string;
+    static watchCannotBeEnabled(): string;
+}
+
 interface TextRange {
     start: number;
     end: number;
@@ -222,6 +127,15 @@ declare class Directive {
     static getInlineConfig(ranges: DirectiveRanges | undefined): Promise<InlineConfig | undefined>;
 }
 
+declare const defaultOptions: Required<ConfigFileOptions>;
+
+declare enum OptionGroup {
+    CommandLine = 2,
+    ConfigFile = 4,
+    InlineConditions = 8,
+    ResolvedConfig = 6
+}
+
 declare enum DiagnosticCategory {
     Error = "error",
     Warning = "warning"
@@ -263,7 +177,7 @@ declare class Diagnostic {
     }): this;
     static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
     extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>): Array<Diagnostic>;
+    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>, sourceFile?: ts.SourceFile): Array<Diagnostic>;
     static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
 }
 
@@ -274,13 +188,6 @@ declare function isDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic
 
 type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
 
-declare enum OptionGroup {
-    CommandLine = 2,
-    ConfigFile = 4,
-    InlineConditions = 8,
-    ResolvedConfig = 6
-}
-
 interface BaseOptionDefinition {
     brand: OptionBrand;
     description: string;
@@ -306,8 +213,6 @@ declare class Options {
     static validate(optionName: string, optionValue: string, optionBrand: OptionBrand, onDiagnostics: DiagnosticsHandler, origin?: DiagnosticOrigin): Promise<void>;
 }
 
-declare const defaultOptions: Required<ConfigFileOptions>;
-
 declare enum TestTreeNodeBrand {
     Describe = "describe",
     Test = "test",
@@ -386,33 +291,12 @@ declare function argumentIsProvided<T>(argumentNameText: string, node: T, enclos
 declare function argumentOrTypeArgumentIsProvided<T>(argumentNameText: string, typeArgumentNameText: string, node: T, enclosingNode: ts.Node, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): node is NonNullable<T>;
 
 interface EnvironmentOptions {
-    /**
-     * Is `true` if the process is running in continuous integration environment.
-     */
     isCi: boolean;
-    /**
-     * Specifies whether color should be disabled in the output.
-     */
     noColor: boolean;
-    /**
-     * Specifies whether interactive elements should be disabled in the output.
-     */
     noInteractive: boolean;
-    /**
-     * The base URL of the 'npm' registry to use.
-     */
     npmRegistry: string;
-    /**
-     * The directory where to store the 'typescript' packages.
-     */
     storePath: string;
-    /**
-     * The number of seconds to wait before giving up stale operations.
-     */
     timeout: number;
-    /**
-     * The specifier of the TypeScript module.
-     */
     typescriptModule: string | undefined;
 }
 
@@ -752,8 +636,6 @@ interface CodeFrameOptions {
 
 declare function diagnosticText(diagnostic: Diagnostic, codeFrameOptions?: CodeFrameOptions): ScribblerJsx.Element;
 
-declare function taskStatusText(status: TaskResultStatus, task: Task): ScribblerJsx.Element;
-
 declare function fileViewText(lines: Array<ScribblerJsx.Element>, addEmptyFinalLine: boolean): ScribblerJsx.Element;
 
 declare function formattedText(input: string | Array<string> | Record<string, unknown>): ScribblerJsx.Element;
@@ -777,6 +659,8 @@ declare function summaryText({ duration, expectCount, fileCount, targetCount, te
     testCount: ResultCount;
 }): ScribblerJsx.Element;
 
+declare function taskStatusText(status: TaskResultStatus, task: Task): ScribblerJsx.Element;
+
 declare function testNameText(status: "fail" | "pass" | "skip" | "todo", name: string, indent?: number): ScribblerJsx.Element;
 
 declare function usesCompilerText(compilerVersion: string, projectConfigFilePath: string | undefined, options?: {
@@ -799,17 +683,8 @@ interface SelectHookContext {
     resolvedConfig: ResolvedConfig;
 }
 interface Plugin {
-    /**
-     * The name of this plugin.
-     */
     name: string;
-    /**
-     * Is called after configuration is resolved and allows to modify it.
-     */
     config?: (resolvedConfig: ResolvedConfig) => ResolvedConfig | Promise<ResolvedConfig>;
-    /**
-     * Is called after test files are selected and allows to modify the list.
-     */
     select?: (this: SelectHookContext, testFiles: Array<string>) => Array<string | URL> | Promise<Array<string | URL>>;
 }
 
@@ -920,4 +795,4 @@ declare class WhenService {
 }
 
 export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
-export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, DirectiveRanges, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InlineConfig, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, TargetResultStatus, TaskResultStatus, TypeChecker, WatchHandler, WatcherOptions };
+export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, DirectiveRanges, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InlineConfig, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, TargetResultStatus, TaskResultStatus, TextRange, TypeChecker, WatchHandler, WatcherOptions };

package/build/tstyche.js

@@ -8,76 +8,6 @@ import { createRequire } from 'node:module';
 import vm from 'node:vm';
 import streamConsumers from 'node:stream/consumers';
 
-class ConfigDiagnosticText {
-    static expected(element) {
-        return `Expected ${element}.`;
-    }
-    static expectsListItemType(optionName, optionBrand) {
-        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
-    }
-    static expectsValue(optionName) {
-        return `Option '${optionName}' expects a value.`;
-    }
-    static fileDoesNotExist(filePath) {
-        return `The specified path '${filePath}' does not exist.`;
-    }
-    static inspectSupportedVersions() {
-        return "Use the '--list' command line option to inspect the list of supported versions.";
-    }
-    static moduleWasNotFound(specifier) {
-        return `The specified module '${specifier}' was not found.`;
-    }
-    static rangeIsNotValid(value) {
-        return `The specified range '${value}' is not valid.`;
-    }
-    static rangeUsage() {
-        return [
-            "A range must be specified using an operator and a minor version.",
-            "To set an upper bound, the intersection of two ranges can be used.",
-            "Examples: '>=5.5', '>=5.0 <5.3'.",
-        ];
-    }
-    static requiresValueType(optionName, optionBrand) {
-        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
-    }
-    static seen(element) {
-        return `The ${element} was seen here.`;
-    }
-    static testFileMatchCannotStartWith(segment) {
-        return [
-            `A test file match pattern cannot start with '${segment}'.`,
-            "The test files are only collected within the 'rootPath' directory.",
-        ];
-    }
-    static unexpected(element) {
-        return `Unexpected ${element}.`;
-    }
-    static unknownOption(optionName) {
-        return `Unknown option '${optionName}'.`;
-    }
-    static usage(optionName, optionBrand) {
-        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
-            case "target": {
-                const text = [];
-                if (optionName.startsWith("--")) {
-                    text.push("Value for the '--target' option must be a string or a comma separated list.", "Examples: '--target 5.2', '--target next', '--target '>=5.0 <5.3, 5.4.2, >=5.5''.");
-                }
-                return text;
-            }
-        }
-        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
-    }
-    static versionIsNotSupported(value) {
-        if (value === "current") {
-            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
-        }
-        return `TypeScript version '${value}' is not supported.`;
-    }
-    static watchCannotBeEnabled() {
-        return "Watch mode cannot be enabled in continuous integration environment.";
-    }
-}
-
 var DiagnosticCategory;
 (function (DiagnosticCategory) {
     DiagnosticCategory["Error"] = "error";
@@ -157,16 +87,16 @@ class Diagnostic {
     extendWith(text, origin) {
         return new Diagnostic([this.text, text].flat(), this.category, origin ?? this.origin);
     }
-    static fromDiagnostics(diagnostics) {
+    static fromDiagnostics(diagnostics, sourceFile) {
         return diagnostics.map((diagnostic) => {
             const code = `ts(${diagnostic.code})`;
             let origin;
-            if (diagnostic.file != null && diagnostic.start != null && diagnostic.length != null) {
-                origin = new DiagnosticOrigin(diagnostic.start, diagnostic.start + diagnostic.length, diagnostic.file);
+            if (isDiagnosticWithLocation(diagnostic)) {
+                origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceFile ?? diagnostic.file);
             }
             let related;
             if (diagnostic.relatedInformation != null) {
-                related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation, sourceFile);
             }
             const text = getDiagnosticMessageText(diagnostic);
             return new Diagnostic(text, DiagnosticCategory.Error, origin).add({ code, related });
@@ -282,6 +212,76 @@ class Path {
     }
 }
 
+class ConfigDiagnosticText {
+    static expected(element) {
+        return `Expected ${element}.`;
+    }
+    static expectsListItemType(optionName, optionBrand) {
+        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
+    }
+    static expectsValue(optionName) {
+        return `Option '${optionName}' expects a value.`;
+    }
+    static fileDoesNotExist(filePath) {
+        return `The specified path '${filePath}' does not exist.`;
+    }
+    static inspectSupportedVersions() {
+        return "Use the '--list' command line option to inspect the list of supported versions.";
+    }
+    static moduleWasNotFound(specifier) {
+        return `The specified module '${specifier}' was not found.`;
+    }
+    static rangeIsNotValid(value) {
+        return `The specified range '${value}' is not valid.`;
+    }
+    static rangeUsage() {
+        return [
+            "A range must be specified using an operator and a minor version.",
+            "To set an upper bound, the intersection of two ranges can be used.",
+            "Examples: '>=5.5', '>=5.0 <5.3'.",
+        ];
+    }
+    static requiresValueType(optionName, optionBrand) {
+        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
+    }
+    static seen(element) {
+        return `The ${element} was seen here.`;
+    }
+    static testFileMatchCannotStartWith(segment) {
+        return [
+            `A test file match pattern cannot start with '${segment}'.`,
+            "The test files are only collected within the 'rootPath' directory.",
+        ];
+    }
+    static unexpected(element) {
+        return `Unexpected ${element}.`;
+    }
+    static unknownOption(optionName) {
+        return `Unknown option '${optionName}'.`;
+    }
+    static usage(optionName, optionBrand) {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
+            case "target": {
+                const text = [];
+                if (optionName.startsWith("--")) {
+                    text.push("Value for the '--target' option must be a string or a comma separated list.", "Examples: '--target 5.2', '--target next', '--target '>=5.0 <5.3, 5.4.2, >=5.5''.");
+                }
+                return text;
+            }
+        }
+        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
+    }
+    static versionIsNotSupported(value) {
+        if (value === "current") {
+            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
+        }
+        return `TypeScript version '${value}' is not supported.`;
+    }
+    static watchCannotBeEnabled() {
+        return "Watch mode cannot be enabled in continuous integration environment.";
+    }
+}
+
 var OptionBrand;
 (function (OptionBrand) {
     OptionBrand["String"] = "string";
@@ -513,7 +513,7 @@ class LockService {
         }
         return isLocked;
     }
-    async #sleep(delay) {
+    #sleep(delay) {
         return new Promise((resolve) => setTimeout(resolve, delay));
     }
 }
@@ -1392,6 +1392,19 @@ class ConfigParser {
     }
 }
 
+const defaultOptions = {
+    checkSourceFiles: true,
+    failFast: false,
+    plugins: [],
+    rejectAnyType: true,
+    rejectNeverType: true,
+    reporters: ["list", "summary"],
+    rootPath: Path.resolve("./"),
+    target: environmentOptions.typescriptModule != null ? ["current"] : ["latest"],
+    testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
+    tsconfig: "findup",
+};
+
 class JsonNode {
     origin;
     text;
@@ -1525,19 +1538,6 @@ class JsonScanner {
     }
 }
 
-const defaultOptions = {
-    checkSourceFiles: true,
-    failFast: false,
-    plugins: [],
-    rejectAnyType: true,
-    rejectNeverType: true,
-    reporters: ["list", "summary"],
-    rootPath: Path.resolve("./"),
-    target: environmentOptions.typescriptModule != null ? ["current"] : ["latest"],
-    testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
-    tsconfig: "findup",
-};
-
 class Config {
     static #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["config:error", { diagnostics: [diagnostic] }]);
@@ -1589,20 +1589,19 @@ class Config {
 }
 
 class DirectiveDiagnosticText {
-    static doesNotTakeArgument(directiveName) {
-        return `Directive '${directiveName}' does not take an argument.`;
+    static doesNotTakeArgument() {
+        return "Directive does not take an argument.";
     }
     static isNotSupported(directive) {
         return `The '${directive}' directive is not supported.`;
     }
-    static requiresArgument(directiveName) {
-        return `Directive '${directiveName}' requires an argument.`;
+    static requiresArgument() {
+        return "Directive requires an argument.";
     }
 }
 
 class Directive {
-    static #commentSeparatorRegex = /--+/;
-    static #directiveRegex = /^(\/\/\s*@tstyche)(\s*|-)?(\S*)?(\s*)?(.*)?/i;
+    static #directiveRegex = /^(\/\/ *@tstyche)( *|-)?(\S*)?( *)?(.*)?/i;
     static getDirectiveRanges(compiler, sourceFile, position = 0) {
         const comments = compiler.getLeadingCommentRanges(sourceFile.text, position);
         if (!comments || comments.length === 0) {
@@ -1631,28 +1630,28 @@ class Directive {
         return inlineConfig;
     }
     static #getRange(sourceFile, comment) {
-        const [text] = sourceFile.text.substring(comment.pos, comment.end).split(Directive.#commentSeparatorRegex);
-        const found = text?.match(Directive.#directiveRegex);
-        const namespaceText = found?.[1];
+        const [text] = sourceFile.text.substring(comment.pos, comment.end).split(/--+/);
+        const match = text?.match(Directive.#directiveRegex);
+        const namespaceText = match?.[1];
         if (!namespaceText) {
             return;
         }
-        const ranges = {
+        const range = {
             namespace: { start: comment.pos, end: comment.pos + namespaceText.length, text: namespaceText },
         };
-        const directiveSeparatorText = found?.[2];
-        const directiveText = found?.[3];
-        if (directiveText != null && directiveText.length > 0) {
-            const start = ranges.namespace.end + (directiveSeparatorText?.length ?? 0);
-            ranges.directive = { start, end: start + directiveText.length, text: directiveText };
-        }
-        const argumentSeparatorText = found?.[4];
-        const argumentText = found?.[5]?.trimEnd();
-        if (ranges.directive != null && argumentText != null && argumentText.length > 0) {
-            const start = ranges.directive.end + (argumentSeparatorText?.length ?? 0);
-            ranges.argument = { start, end: start + argumentText.length, text: argumentText };
+        const directiveSeparatorText = match?.[2];
+        const directiveText = match?.[3];
+        if (typeof directiveText === "string" && typeof directiveSeparatorText === "string") {
+            const start = range.namespace.end + directiveSeparatorText.length;
+            range.directive = { start, end: start + directiveText.length, text: directiveText };
+            const argumentSeparatorText = match?.[4];
+            const argumentText = match?.[5]?.trimEnd();
+            if (typeof argumentSeparatorText === "string" && typeof argumentText === "string") {
+                const start = range.directive.end + argumentSeparatorText.length;
+                range.argument = { start, end: start + argumentText.length, text: argumentText };
+            }
         }
-        return ranges;
+        return range;
     }
     static #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["directive:error", { diagnostics: [diagnostic] }]);
@@ -1662,8 +1661,8 @@ class Directive {
             case "if":
                 {
                     if (!ranges.argument?.text) {
-                        const text = DirectiveDiagnosticText.requiresArgument(ranges.directive.text);
-                        const origin = new DiagnosticOrigin(ranges.directive.start, ranges.directive.end, sourceFile);
+                        const text = DirectiveDiagnosticText.requiresArgument();
+                        const origin = new DiagnosticOrigin(ranges.namespace.start, ranges.directive.end, sourceFile);
                         Directive.#onDiagnostics(Diagnostic.error(text, origin));
                         return;
                     }
@@ -1673,8 +1672,8 @@ class Directive {
                 return;
             case "template":
                 if (ranges.argument?.text != null) {
-                    const text = DirectiveDiagnosticText.doesNotTakeArgument(ranges.directive.text);
-                    const origin = new DiagnosticOrigin(ranges.directive.start, ranges.directive.end, sourceFile);
+                    const text = DirectiveDiagnosticText.doesNotTakeArgument();
+                    const origin = new DiagnosticOrigin(ranges.argument.start, ranges.argument.end, sourceFile);
                     Directive.#onDiagnostics(Diagnostic.error(text, origin));
                 }
                 inlineConfig.template = true;
@@ -2131,7 +2130,9 @@ function describeNameText(name, indent = 0) {
 function BreadcrumbsText({ ancestor }) {
     const text = [];
     while ("name" in ancestor) {
-        text.push(ancestor.name);
+        if (ancestor.name !== "") {
+            text.push(ancestor.name);
+        }
         ancestor = ancestor.parent;
     }
     text.push("");
@@ -2215,33 +2216,6 @@ function diagnosticText(diagnostic, codeFrameOptions = {}) {
     return (jsx(Text, { children: [prefix, jsx(DiagnosticText, { codeFrameOptions: codeFrameOptions, diagnostic: diagnostic })] }));
 }
 
-function FileNameText({ filePath }) {
-    const relativePath = Path.relative("", filePath);
-    const lastPathSeparator = relativePath.lastIndexOf("/");
-    const directoryNameText = relativePath.slice(0, lastPathSeparator + 1);
-    const fileNameText = relativePath.slice(lastPathSeparator + 1);
-    return (jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: directoryNameText }), fileNameText] }));
-}
-function taskStatusText(status, task) {
-    let statusColor;
-    let statusText;
-    switch (status) {
-        case ResultStatus.Runs:
-            statusColor = Color.Yellow;
-            statusText = "runs";
-            break;
-        case ResultStatus.Passed:
-            statusColor = Color.Green;
-            statusText = "pass";
-            break;
-        case ResultStatus.Failed:
-            statusColor = Color.Red;
-            statusText = "fail";
-            break;
-    }
-    return (jsx(Line, { children: [jsx(Text, { color: statusColor, children: statusText }), " ", jsx(FileNameText, { filePath: task.filePath })] }));
-}
-
 function fileViewText(lines, addEmptyFinalLine) {
     return (jsx(Text, { children: [[...lines], addEmptyFinalLine ? jsx(Line, {}) : undefined] }));
 }
@@ -2361,6 +2335,33 @@ function summaryText({ duration, expectCount, fileCount, targetCount, testCount,
     return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) })] }));
 }
 
+function FileNameText({ filePath }) {
+    const relativePath = Path.relative("", filePath);
+    const lastPathSeparator = relativePath.lastIndexOf("/");
+    const directoryNameText = relativePath.slice(0, lastPathSeparator + 1);
+    const fileNameText = relativePath.slice(lastPathSeparator + 1);
+    return (jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: directoryNameText }), fileNameText] }));
+}
+function taskStatusText(status, task) {
+    let statusColor;
+    let statusText;
+    switch (status) {
+        case ResultStatus.Runs:
+            statusColor = Color.Yellow;
+            statusText = "runs";
+            break;
+        case ResultStatus.Passed:
+            statusColor = Color.Green;
+            statusText = "pass";
+            break;
+        case ResultStatus.Failed:
+            statusColor = Color.Red;
+            statusText = "fail";
+            break;
+    }
+    return (jsx(Line, { children: [jsx(Text, { color: statusColor, children: statusText }), " ", jsx(FileNameText, { filePath: task.filePath })] }));
+}
+
 function StatusText({ status }) {
     switch (status) {
         case "fail":
@@ -2646,6 +2647,14 @@ class Task {
     }
 }
 
+var CancellationReason;
+(function (CancellationReason) {
+    CancellationReason["ConfigChange"] = "configChange";
+    CancellationReason["ConfigError"] = "configError";
+    CancellationReason["FailFast"] = "failFast";
+    CancellationReason["WatchClose"] = "watchClose";
+})(CancellationReason || (CancellationReason = {}));
+
 class CancellationToken {
     #isCancelled = false;
     #reason;
@@ -2669,14 +2678,6 @@ class CancellationToken {
     }
 }
 
-var CancellationReason;
-(function (CancellationReason) {
-    CancellationReason["ConfigChange"] = "configChange";
-    CancellationReason["ConfigError"] = "configError";
-    CancellationReason["FailFast"] = "failFast";
-    CancellationReason["WatchClose"] = "watchClose";
-})(CancellationReason || (CancellationReason = {}));
-
 class Watcher {
     #onChanged;
     #onRemoved;
@@ -3066,6 +3067,7 @@ function nodeIsChildOfExpressionStatement(compiler, node) {
 
 class AbilityLayer {
     #compiler;
+    #expectErrorRegex = /^( *)(\/\/ *@ts-expect-error)(!?)(:? *)(.*)?$/gim;
     #filePath = "";
     #nodes = [];
     #projectService;
@@ -3076,6 +3078,30 @@ class AbilityLayer {
         this.#projectService = projectService;
         this.#resolvedConfig = resolvedConfig;
     }
+    #collectSuppressedErrors() {
+        const ranges = [];
+        for (const match of this.#text.matchAll(this.#expectErrorRegex)) {
+            const offsetText = match?.[1];
+            const directiveText = match?.[2];
+            const ignoreText = match?.[3];
+            const argumentSeparatorText = match?.[4];
+            const argumentText = match?.[5]?.split(/--+/)[0]?.trimEnd();
+            if (typeof offsetText !== "string" || !directiveText || ignoreText === "!") {
+                continue;
+            }
+            const start = match.index + offsetText.length;
+            const range = {
+                directive: { start, end: start + directiveText.length, text: directiveText },
+                diagnostics: [],
+            };
+            if (typeof argumentSeparatorText === "string" && typeof argumentText === "string") {
+                const start = range.directive.end + argumentSeparatorText.length;
+                range.argument = { start, end: start + argumentText.length, text: argumentText };
+            }
+            ranges.push(range);
+        }
+        return ranges;
+    }
     #getErasedRangeText(range) {
         if (this.#text.indexOf("\n", range.start) >= range.end) {
             return " ".repeat(range.end - range.start);
@@ -3184,9 +3210,18 @@ class AbilityLayer {
                 break;
         }
     }
+    #handleSuppressedErrors() {
+        const suppressedErrors = this.#collectSuppressedErrors();
+        for (const suppressedError of suppressedErrors) {
+            const { start, end } = suppressedError.directive;
+            const rangeText = this.#getErasedRangeText({ start: start + 2, end });
+            this.#text = `${this.#text.slice(0, start + 2)}${rangeText}${this.#text.slice(end)}`;
+        }
+    }
     open(sourceFile) {
         this.#filePath = sourceFile.fileName;
         this.#text = sourceFile.text;
+        this.#handleSuppressedErrors();
     }
 }
 
@@ -3641,6 +3676,7 @@ var RunMode;
     RunMode[RunMode["Only"] = 2] = "Only";
     RunMode[RunMode["Skip"] = 4] = "Skip";
     RunMode[RunMode["Todo"] = 8] = "Todo";
+    RunMode[RunMode["Void"] = 16] = "Void";
 })(RunMode || (RunMode = {}));
 
 class EnsureDiagnosticText {
@@ -4170,69 +4206,75 @@ class ToBeAssignableWith extends RelationMatcherBase {
     }
 }
 
-class ToBeCallableWith {
-    #compiler;
+class AbilityMatcherBase {
+    compiler;
     constructor(compiler) {
-        this.#compiler = compiler;
+        this.compiler = compiler;
     }
     #resolveTargetText(nodes) {
         if (nodes.length === 0) {
             return "without arguments";
         }
-        if (nodes.length === 1 && nodes[0]?.kind === this.#compiler.SyntaxKind.SpreadElement) {
+        if (nodes.length === 1 && nodes[0]?.kind === this.compiler.SyntaxKind.SpreadElement) {
             return "with the given arguments";
         }
         return `with the given argument${nodes.length === 1 ? "" : "s"}`;
     }
-    #explain(matchWorker, sourceNode, targetNodes) {
-        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
+    explain(matchWorker, sourceNode, targetNodes) {
+        const isExpression = nodeBelongsToArgumentList(this.compiler, sourceNode);
         const targetText = this.#resolveTargetText(targetNodes);
         const diagnostics = [];
         if (matchWorker.assertion.abilityDiagnostics) {
             for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
-                const text = [
-                    ExpectDiagnosticText.isNotCallable(isExpression, targetText),
-                    getDiagnosticMessageText(diagnostic),
-                ];
                 let origin;
-                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
-                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
+                const text = [];
+                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, sourceNode)) {
+                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertion);
+                    text.push(getDiagnosticMessageText(diagnostic));
                 }
                 else {
-                    origin =
-                        targetNodes.length > 0
-                            ? DiagnosticOrigin.fromNodes(targetNodes)
-                            : DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+                    if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
+                        origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertion);
+                    }
+                    else {
+                        origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+                    }
+                    text.push(this.explainNotText(isExpression, targetText), getDiagnosticMessageText(diagnostic));
                 }
                 let related;
                 if (diagnostic.relatedInformation != null) {
-                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation, sourceNode.getSourceFile());
                 }
                 diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
             }
         }
         else {
             const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isCallable(isExpression, targetText), origin));
+            diagnostics.push(Diagnostic.error(this.explainText(isExpression, targetText), origin));
         }
         return diagnostics;
     }
+}
+
+class ToBeCallableWith extends AbilityMatcherBase {
+    explainText = ExpectDiagnosticText.isCallable;
+    explainNotText = ExpectDiagnosticText.isNotCallable;
     match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
         let type;
-        if (this.#compiler.isCallExpression(sourceNode)) {
+        if (this.compiler.isCallExpression(sourceNode)) {
             type = matchWorker.typeChecker.getResolvedSignature(sourceNode)?.getReturnType();
         }
-        if (this.#compiler.isArrowFunction(sourceNode) ||
-            this.#compiler.isFunctionDeclaration(sourceNode) ||
-            this.#compiler.isFunctionExpression(sourceNode) ||
-            this.#compiler.isExpressionWithTypeArguments(sourceNode) ||
-            this.#compiler.isIdentifier(sourceNode) ||
-            this.#compiler.isPropertyAccessExpression(sourceNode)) {
+        if (this.compiler.isArrowFunction(sourceNode) ||
+            this.compiler.isFunctionDeclaration(sourceNode) ||
+            this.compiler.isFunctionExpression(sourceNode) ||
+            this.compiler.isExpressionWithTypeArguments(sourceNode) ||
+            this.compiler.isIdentifier(sourceNode) ||
+            this.compiler.isPropertyAccessExpression(sourceNode)) {
             type = matchWorker.getType(sourceNode);
         }
         if (!type || type.getCallSignatures().length === 0) {
             const text = [];
-            if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+            if (nodeBelongsToArgumentList(this.compiler, sourceNode)) {
                 text.push(ExpectDiagnosticText.argumentMustBe("source", "a callable expression"));
             }
             else {
@@ -4246,72 +4288,28 @@ class ToBeCallableWith {
             return;
         }
         return {
-            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            explain: () => this.explain(matchWorker, sourceNode, targetNodes),
             isMatch: !matchWorker.assertion.abilityDiagnostics,
         };
     }
 }
 
-class ToBeConstructableWith {
-    #compiler;
-    constructor(compiler) {
-        this.#compiler = compiler;
-    }
-    #resolveTargetText(nodes) {
-        if (nodes.length === 0) {
-            return "without arguments";
-        }
-        if (nodes.length === 1 && nodes[0]?.kind === this.#compiler.SyntaxKind.SpreadElement) {
-            return "with the given arguments";
-        }
-        return `with the given argument${nodes.length === 1 ? "" : "s"}`;
-    }
-    #explain(matchWorker, sourceNode, targetNodes) {
-        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
-        const targetText = this.#resolveTargetText(targetNodes);
-        const diagnostics = [];
-        if (matchWorker.assertion.abilityDiagnostics) {
-            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
-                const text = [
-                    ExpectDiagnosticText.isNotConstructable(isExpression, targetText),
-                    getDiagnosticMessageText(diagnostic),
-                ];
-                let origin;
-                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
-                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
-                }
-                else {
-                    origin =
-                        targetNodes.length > 0
-                            ? DiagnosticOrigin.fromNodes(targetNodes)
-                            : DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-                }
-                let related;
-                if (diagnostic.relatedInformation != null) {
-                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
-                }
-                diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
-            }
-        }
-        else {
-            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isConstructable(isExpression, targetText), origin));
-        }
-        return diagnostics;
-    }
+class ToBeConstructableWith extends AbilityMatcherBase {
+    explainText = ExpectDiagnosticText.isConstructable;
+    explainNotText = ExpectDiagnosticText.isNotConstructable;
     match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
         let type;
-        if (this.#compiler.isCallExpression(sourceNode)) {
+        if (this.compiler.isCallExpression(sourceNode)) {
             type = matchWorker.typeChecker.getResolvedSignature(sourceNode)?.getReturnType();
         }
-        if (this.#compiler.isExpressionWithTypeArguments(sourceNode) ||
-            this.#compiler.isIdentifier(sourceNode) ||
-            this.#compiler.isPropertyAccessExpression(sourceNode)) {
+        if (this.compiler.isExpressionWithTypeArguments(sourceNode) ||
+            this.compiler.isIdentifier(sourceNode) ||
+            this.compiler.isPropertyAccessExpression(sourceNode)) {
             type = matchWorker.getType(sourceNode);
         }
         if (!type || type.getConstructSignatures().length === 0) {
             const text = [];
-            if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+            if (nodeBelongsToArgumentList(this.compiler, sourceNode)) {
                 text.push(ExpectDiagnosticText.argumentMustBe("source", "a constructable expression"));
             }
             else {
@@ -4325,7 +4323,7 @@ class ToBeConstructableWith {
             return;
         }
         return {
-            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            explain: () => this.explain(matchWorker, sourceNode, targetNodes),
             isMatch: !matchWorker.assertion.abilityDiagnostics,
         };
     }
@@ -4686,7 +4684,7 @@ class TestTreeWalker {
         const directiveRanges = node.getDirectiveRanges(this.#compiler);
         const inlineConfig = await Directive.getInlineConfig(directiveRanges);
         if (inlineConfig?.if?.target != null && !Version.isIncluded(this.#compiler.version, inlineConfig.if.target)) {
-            mode |= RunMode.Skip;
+            mode |= RunMode.Void;
         }
         if (node.flags & TestTreeNodeFlags.Fail) {
             mode |= RunMode.Fail;
@@ -4731,9 +4729,12 @@ class TestTreeWalker {
     }
     async #visitAssertion(assertion, runMode, parentResult) {
         await this.visit(assertion.children, runMode, parentResult);
+        runMode = await this.#resolveRunMode(runMode, assertion);
+        if (runMode & RunMode.Void) {
+            return;
+        }
         const expectResult = new ExpectResult(assertion, parentResult);
         EventEmitter.dispatch(["expect:start", { result: expectResult }]);
-        runMode = await this.#resolveRunMode(runMode, assertion);
         if (runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only))) {
             EventEmitter.dispatch(["expect:skip", { result: expectResult }]);
             return;
@@ -4770,9 +4771,12 @@ class TestTreeWalker {
         }
     }
     async #visitDescribe(describe, runMode, parentResult) {
+        runMode = await this.#resolveRunMode(runMode, describe);
+        if (runMode & RunMode.Void) {
+            return;
+        }
         const describeResult = new DescribeResult(describe, parentResult);
         EventEmitter.dispatch(["describe:start", { result: describeResult }]);
-        runMode = await this.#resolveRunMode(runMode, describe);
         if (!(runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only)) || runMode & RunMode.Todo) &&
             describe.diagnostics.size > 0) {
             this.#onTaskDiagnostics(Diagnostic.fromDiagnostics([...describe.diagnostics]));
@@ -4783,9 +4787,12 @@ class TestTreeWalker {
         EventEmitter.dispatch(["describe:end", { result: describeResult }]);
     }
     async #visitTest(test, runMode, parentResult) {
+        runMode = await this.#resolveRunMode(runMode, test);
+        if (runMode & RunMode.Void) {
+            return;
+        }
         const testResult = new TestResult(test, parentResult);
         EventEmitter.dispatch(["test:start", { result: testResult }]);
-        runMode = await this.#resolveRunMode(runMode, test);
         if (runMode & RunMode.Todo) {
             EventEmitter.dispatch(["test:todo", { result: testResult }]);
             return;
@@ -4906,7 +4913,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0";
+    static version = "4.0.2";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",