tstyche 3.0.0-beta.1 → 3.0.0-beta.2

package/build/tstyche.js

@@ -87,15 +87,6 @@ class DescribeResult {
     }
 }
 
-var ResultStatus;
-(function (ResultStatus) {
-    ResultStatus["Runs"] = "runs";
-    ResultStatus["Passed"] = "passed";
-    ResultStatus["Failed"] = "failed";
-    ResultStatus["Skipped"] = "skipped";
-    ResultStatus["Todo"] = "todo";
-})(ResultStatus || (ResultStatus = {}));
-
 class ExpectResult {
     assertion;
     diagnostics = [];
@@ -144,6 +135,15 @@ class Result {
     }
 }
 
+var ResultStatus;
+(function (ResultStatus) {
+    ResultStatus["Runs"] = "runs";
+    ResultStatus["Passed"] = "passed";
+    ResultStatus["Failed"] = "failed";
+    ResultStatus["Skipped"] = "skipped";
+    ResultStatus["Todo"] = "todo";
+})(ResultStatus || (ResultStatus = {}));
+
 class TargetResult {
     results = new Map();
     status = "runs";
@@ -193,23 +193,20 @@ class ResultHandler {
     #testResult;
     handleEvent([eventName, payload]) {
         switch (eventName) {
-            case "run:start": {
+            case "run:start":
                 this.#result = payload.result;
                 this.#result.timing.start = Date.now();
                 break;
-            }
-            case "run:end": {
+            case "run:end":
                 this.#result.timing.end = Date.now();
                 this.#result = undefined;
                 break;
-            }
-            case "target:start": {
+            case "target:start":
                 this.#result.results.push(payload.result);
                 this.#targetResult = payload.result;
                 this.#targetResult.timing.start = Date.now();
                 break;
-            }
-            case "target:end": {
+            case "target:end":
                 if (this.#targetResult.status === "failed") {
                     this.#result.targetCount.failed++;
                 }
@@ -220,13 +217,11 @@ class ResultHandler {
                 this.#targetResult.timing.end = Date.now();
                 this.#targetResult = undefined;
                 break;
-            }
-            case "store:error": {
+            case "store:error":
                 if (payload.diagnostics.some(({ category }) => category === "error")) {
                     this.#targetResult.status = "failed";
                 }
                 break;
-            }
             case "project:uses": {
                 let projectResult = this.#targetResult.results.get(payload.projectConfigFilePath);
                 if (!projectResult) {
@@ -236,24 +231,21 @@ class ResultHandler {
                 this.#projectResult = projectResult;
                 break;
             }
-            case "project:error": {
+            case "project:error":
                 this.#targetResult.status = "failed";
                 this.#projectResult.diagnostics.push(...payload.diagnostics);
                 break;
-            }
-            case "task:start": {
+            case "task:start":
                 this.#projectResult.results.push(payload.result);
                 this.#taskResult = payload.result;
                 this.#taskResult.timing.start = Date.now();
                 break;
-            }
-            case "task:error": {
+            case "task:error":
                 this.#targetResult.status = "failed";
                 this.#taskResult.status = "failed";
                 this.#taskResult.diagnostics.push(...payload.diagnostics);
                 break;
-            }
-            case "task:end": {
+            case "task:end":
                 if (this.#taskResult.status === "failed" ||
                     this.#taskResult.expectCount.failed > 0 ||
                     this.#taskResult.testCount.failed > 0) {
@@ -268,8 +260,7 @@ class ResultHandler {
                 this.#taskResult.timing.end = Date.now();
                 this.#taskResult = undefined;
                 break;
-            }
-            case "describe:start": {
+            case "describe:start":
                 if (this.#describeResult) {
                     this.#describeResult.results.push(payload.result);
                 }
@@ -279,13 +270,11 @@ class ResultHandler {
                 this.#describeResult = payload.result;
                 this.#describeResult.timing.start = Date.now();
                 break;
-            }
-            case "describe:end": {
+            case "describe:end":
                 this.#describeResult.timing.end = Date.now();
                 this.#describeResult = this.#describeResult.parent;
                 break;
-            }
-            case "test:start": {
+            case "test:start":
                 if (this.#describeResult) {
                     this.#describeResult.results.push(payload.result);
                 }
@@ -295,8 +284,7 @@ class ResultHandler {
                 this.#testResult = payload.result;
                 this.#testResult.timing.start = Date.now();
                 break;
-            }
-            case "test:error": {
+            case "test:error":
                 this.#result.testCount.failed++;
                 this.#taskResult.testCount.failed++;
                 this.#testResult.status = "failed";
@@ -304,40 +292,35 @@ class ResultHandler {
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
-            }
-            case "test:fail": {
+            case "test:fail":
                 this.#result.testCount.failed++;
                 this.#taskResult.testCount.failed++;
                 this.#testResult.status = "failed";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
-            }
-            case "test:pass": {
+            case "test:pass":
                 this.#result.testCount.passed++;
                 this.#taskResult.testCount.passed++;
                 this.#testResult.status = "passed";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
-            }
-            case "test:skip": {
+            case "test:skip":
                 this.#result.testCount.skipped++;
                 this.#taskResult.testCount.skipped++;
                 this.#testResult.status = "skipped";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
-            }
-            case "test:todo": {
+            case "test:todo":
                 this.#result.testCount.todo++;
                 this.#taskResult.testCount.todo++;
                 this.#testResult.status = "todo";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
-            }
-            case "expect:start": {
+            case "expect:start":
                 if (this.#testResult) {
                     this.#testResult.results.push(payload.result);
                 }
@@ -347,8 +330,7 @@ class ResultHandler {
                 this.#expectResult = payload.result;
                 this.#expectResult.timing.start = Date.now();
                 break;
-            }
-            case "expect:error": {
+            case "expect:error":
                 this.#result.expectCount.failed++;
                 this.#taskResult.expectCount.failed++;
                 if (this.#testResult) {
@@ -359,8 +341,7 @@ class ResultHandler {
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
-            }
-            case "expect:fail": {
+            case "expect:fail":
                 this.#result.expectCount.failed++;
                 this.#taskResult.expectCount.failed++;
                 if (this.#testResult) {
@@ -370,8 +351,7 @@ class ResultHandler {
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
-            }
-            case "expect:pass": {
+            case "expect:pass":
                 this.#result.expectCount.passed++;
                 this.#taskResult.expectCount.passed++;
                 if (this.#testResult) {
@@ -381,8 +361,7 @@ class ResultHandler {
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
-            }
-            case "expect:skip": {
+            case "expect:skip":
                 this.#result.expectCount.skipped++;
                 this.#taskResult.expectCount.skipped++;
                 if (this.#testResult) {
@@ -392,7 +371,6 @@ class ResultHandler {
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
-            }
         }
     }
 }
@@ -530,29 +508,25 @@ function SquiggleLineText({ gutterWidth, indentWidth = 0, squiggleColor, squiggl
     return (jsx(Line, { children: [" ".repeat(gutterWidth), jsx(Text, { color: "90", children: " | " }), " ".repeat(indentWidth), jsx(Text, { color: squiggleColor, children: "~".repeat(squiggleWidth === 0 ? 1 : squiggleWidth) })] }));
 }
 function CodeSpanText({ diagnosticCategory, diagnosticOrigin }) {
-    const lastLineInFile = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.sourceFile.text.length).line;
+    const lineMap = diagnosticOrigin.sourceFile.getLineStarts();
     const { character: firstMarkedLineCharacter, line: firstMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.start);
     const { character: lastMarkedLineCharacter, line: lastMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.end);
     const firstLine = Math.max(firstMarkedLine - 2, 0);
-    const lastLine = Math.min(firstLine + 5, lastLineInFile);
+    const lastLine = Math.min(firstLine + 5, lineMap.length - 1);
     const gutterWidth = (lastLine + 1).toString().length + 2;
     let highlightColor;
     switch (diagnosticCategory) {
-        case "error": {
+        case "error":
             highlightColor = "31";
             break;
-        }
-        case "warning": {
+        case "warning":
             highlightColor = "33";
             break;
-        }
     }
     const codeSpan = [];
     for (let index = firstLine; index <= lastLine; index++) {
-        const lineStart = diagnosticOrigin.sourceFile.getPositionOfLineAndCharacter(index, 0);
-        const lineEnd = index === lastLineInFile
-            ? diagnosticOrigin.sourceFile.text.length
-            : diagnosticOrigin.sourceFile.getPositionOfLineAndCharacter(index + 1, 0);
+        const lineStart = lineMap[index];
+        const lineEnd = index === lineMap.length - 1 ? diagnosticOrigin.sourceFile.text.length : lineMap[index + 1];
         const lineText = diagnosticOrigin.sourceFile.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
         if (index >= firstMarkedLine && index <= lastMarkedLine) {
             codeSpan.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumber: index + 1, lineNumberColor: highlightColor, lineText: lineText }));
@@ -588,14 +562,12 @@ function DiagnosticText({ diagnostic }) {
 function diagnosticText(diagnostic) {
     let prefix;
     switch (diagnostic.category) {
-        case "error": {
+        case "error":
             prefix = jsx(Text, { color: "31", children: "Error: " });
             break;
-        }
-        case "warning": {
+        case "warning":
             prefix = jsx(Text, { color: "33", children: "Warning: " });
             break;
-        }
     }
     return (jsx(Text, { children: [prefix, jsx(DiagnosticText, { diagnostic: diagnostic })] }));
 }
@@ -611,21 +583,18 @@ function taskStatusText(status, task) {
     let statusColor;
     let statusText;
     switch (status) {
-        case "runs": {
+        case "runs":
             statusColor = "33";
             statusText = "runs";
             break;
-        }
-        case "passed": {
+        case "passed":
             statusColor = "32";
             statusText = "pass";
             break;
-        }
-        case "failed": {
+        case "failed":
             statusColor = "31";
             statusText = "fail";
             break;
-        }
     }
     return (jsx(Line, { children: [jsx(Text, { color: statusColor, children: statusText }), " ", jsx(FileNameText, { filePath: task.filePath })] }));
 }
@@ -701,8 +670,8 @@ function helpText(optionDefinitions, tstycheVersion) {
 }
 
 class ConfigDiagnosticText {
-    static doubleQuotesExpected() {
-        return "String literal with double quotes expected.";
+    static expected(element) {
+        return `Expected ${element}.`;
     }
     static expectsListItemType(optionName, optionBrand) {
         return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
@@ -722,6 +691,9 @@ class ConfigDiagnosticText {
                 return optionName;
         }
     }
+    static seen(element) {
+        return `The ${element} was seen here.`;
+    }
     static testFileMatchCannotStartWith(segment) {
         return [
             `A test file match pattern cannot start with '${segment}'.`,
@@ -761,9 +733,6 @@ class DiagnosticOrigin {
         const node = assertion.matcherName;
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
-    static fromJsonNode(node, sourceFile, skipTrivia) {
-        return new DiagnosticOrigin(skipTrivia(node.pos, sourceFile), node.end, sourceFile);
-    }
     static fromNode(node, assertion) {
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
@@ -824,8 +793,48 @@ var DiagnosticCategory;
     DiagnosticCategory["Warning"] = "warning";
 })(DiagnosticCategory || (DiagnosticCategory = {}));
 
+class SourceFile {
+    fileName;
+    #lineMap;
+    text;
+    constructor(fileName, text) {
+        this.fileName = fileName;
+        this.text = text;
+        this.#lineMap = this.#createLineMap();
+    }
+    #createLineMap() {
+        const result = [0];
+        let position = 0;
+        while (position < this.text.length) {
+            if (this.text.charAt(position - 1) === "\r") {
+                position++;
+            }
+            if (this.text.charAt(position - 1) === "\n") {
+                result.push(position);
+            }
+            position++;
+        }
+        result.push(position);
+        return result;
+    }
+    getLineStarts() {
+        return this.#lineMap;
+    }
+    getLineAndCharacterOfPosition(position) {
+        const line = this.#lineMap.findLastIndex((line) => line <= position);
+        const character = position - this.#lineMap[line];
+        return { line, character };
+    }
+}
+
 class OptionDefinitionsMap {
     static #definitions = [
+        {
+            brand: "string",
+            description: "The Url to the config file validation schema.",
+            group: 4,
+            name: "$schema",
+        },
         {
             brand: "string",
             description: "The path to a TSTyche configuration file.",
@@ -949,14 +958,12 @@ class OptionUsageText {
         switch (optionName) {
             case "target": {
                 switch (this.#optionGroup) {
-                    case 2: {
+                    case 2:
                         usageText.push("Value for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target latest', '--target 4.9,5.3.2,current'.");
                         break;
-                    }
-                    case 4: {
+                    case 4:
                         usageText.push("Item of the 'target' list must be a supported version tag.");
                         break;
-                    }
                 }
                 const supportedTags = await this.#storeService.getSupportedTags();
                 if (supportedTags != null) {
@@ -1062,13 +1069,12 @@ class OptionValidator {
     async check(optionName, optionValue, optionBrand, origin) {
         switch (optionName) {
             case "config":
-            case "rootPath": {
+            case "rootPath":
                 if (!existsSync(optionValue)) {
                     this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.fileDoesNotExist(optionValue), origin));
                 }
                 break;
-            }
-            case "target": {
+            case "target":
                 if ((await this.#storeService.validateTag(optionValue)) === false) {
                     this.#onDiagnostics(Diagnostic.error([
                         ConfigDiagnosticText.versionIsNotSupported(optionValue),
@@ -1076,21 +1082,18 @@ class OptionValidator {
                     ], origin));
                 }
                 break;
-            }
-            case "testFileMatch": {
+            case "testFileMatch":
                 for (const segment of ["/", "../"]) {
                     if (optionValue.startsWith(segment)) {
                         this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.testFileMatchCannotStartWith(segment), origin));
                     }
                 }
                 break;
-            }
-            case "watch": {
+            case "watch":
                 if (environmentOptions.isCi) {
                     this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.watchCannotBeEnabled(), origin));
                 }
                 break;
-            }
         }
     }
 }
@@ -1147,20 +1150,18 @@ class CommandLineOptionsWorker {
     async #parseOptionValue(commandLineArgs, index, optionDefinition) {
         let optionValue = this.#resolveOptionValue(commandLineArgs[index]);
         switch (optionDefinition.brand) {
-            case "bareTrue": {
+            case "bareTrue":
                 await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
                 this.#commandLineOptions[optionDefinition.name] = true;
                 break;
-            }
-            case "boolean": {
+            case "boolean":
                 await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
                 this.#commandLineOptions[optionDefinition.name] = optionValue !== "false";
                 if (optionValue === "false" || optionValue === "true") {
                     index++;
                 }
                 break;
-            }
-            case "list": {
+            case "list":
                 if (optionValue !== "") {
                     const optionValues = optionValue
                         .split(",")
@@ -1175,8 +1176,7 @@ class CommandLineOptionsWorker {
                 }
                 await this.#onExpectsValue(optionDefinition);
                 break;
-            }
-            case "string": {
+            case "string":
                 if (optionValue !== "") {
                     if (optionDefinition.name === "config") {
                         optionValue = Path.resolve(optionValue);
@@ -1188,7 +1188,6 @@ class CommandLineOptionsWorker {
                 }
                 await this.#onExpectsValue(optionDefinition);
                 break;
-            }
         }
         return index;
     }
@@ -1197,150 +1196,296 @@ class CommandLineOptionsWorker {
     }
 }
 
+class JsonNode {
+    origin;
+    text;
+    constructor(text, origin) {
+        this.origin = origin;
+        this.text = text;
+    }
+    getValue(options) {
+        if (this.text == null) {
+            return undefined;
+        }
+        if (/^['"]/.test(this.text)) {
+            return this.text.slice(1, -1);
+        }
+        if (options?.expectsIdentifier) {
+            return this.text;
+        }
+        if (this.text === "true") {
+            return true;
+        }
+        if (this.text === "false") {
+            return false;
+        }
+        if (/^\d/.test(this.text)) {
+            return Number.parseFloat(this.text);
+        }
+        return undefined;
+    }
+}
+
+class JsonScanner {
+    #currentPosition = 0;
+    #previousPosition = 0;
+    #sourceFile;
+    constructor(sourceFile) {
+        this.#sourceFile = sourceFile;
+    }
+    #getOrigin() {
+        return new DiagnosticOrigin(this.#previousPosition, this.#currentPosition, this.#sourceFile);
+    }
+    isRead() {
+        return !(this.#currentPosition < this.#sourceFile.text.length);
+    }
+    #peekCharacter() {
+        return this.#sourceFile.text.charAt(this.#currentPosition);
+    }
+    #peekNextCharacter() {
+        return this.#sourceFile.text.charAt(this.#currentPosition + 1);
+    }
+    peekToken(token) {
+        this.#skipTrivia();
+        return this.#peekCharacter() === token;
+    }
+    read() {
+        this.#skipTrivia();
+        if (/[:\]}]/.test(this.#peekCharacter())) {
+            return new JsonNode(undefined, this.#getOrigin());
+        }
+        let quoteCharacter = "";
+        let text = "";
+        this.#previousPosition = this.#currentPosition;
+        if (/['"]/.test(this.#peekCharacter())) {
+            quoteCharacter = text += this.#readCharacter();
+        }
+        while (!this.isRead()) {
+            text += this.#readCharacter();
+            if (text.slice(-1) === quoteCharacter || (!quoteCharacter && /[\s,:\]}]/.test(this.#peekCharacter()))) {
+                break;
+            }
+        }
+        return new JsonNode(text, this.#getOrigin());
+    }
+    #readCharacter() {
+        return this.#sourceFile.text.charAt(this.#currentPosition++);
+    }
+    readToken(token) {
+        this.#skipTrivia();
+        this.#previousPosition = this.#currentPosition;
+        if (this.#peekCharacter() === token) {
+            this.#currentPosition++;
+            return new JsonNode(token, this.#getOrigin());
+        }
+        return new JsonNode(undefined, this.#getOrigin());
+    }
+    skip() {
+        this.#skipTrivia();
+        this.#previousPosition = this.#currentPosition;
+        if (/[\s,:\]}]/.test(this.#peekCharacter())) {
+            return new JsonNode(undefined, this.#getOrigin());
+        }
+        let text = "";
+        let closingCharacter = "";
+        if (/[[{'"]/.test(this.#peekCharacter())) {
+            text += this.#readCharacter();
+            switch (text) {
+                case "[":
+                    closingCharacter = "]";
+                    break;
+                case "{":
+                    closingCharacter = "}";
+                    break;
+                default:
+                    closingCharacter = text;
+            }
+        }
+        while (!this.isRead()) {
+            text += this.#readCharacter();
+            if (text.slice(-1) === closingCharacter || (!closingCharacter && /[\s,:\]}]/.test(this.#peekCharacter()))) {
+                break;
+            }
+        }
+        return new JsonNode(text, this.#getOrigin());
+    }
+    #skipTrivia() {
+        while (!this.isRead()) {
+            if (/\s/.test(this.#peekCharacter())) {
+                this.#currentPosition++;
+                continue;
+            }
+            if (this.#peekCharacter() === "/") {
+                if (this.#peekNextCharacter() === "/") {
+                    this.#currentPosition += 2;
+                    while (!this.isRead()) {
+                        if (this.#readCharacter() === "\n") {
+                            break;
+                        }
+                    }
+                    continue;
+                }
+                if (this.#peekNextCharacter() === "*") {
+                    this.#currentPosition += 2;
+                    while (!this.isRead()) {
+                        if (this.#peekCharacter() === "*" && this.#peekNextCharacter() === "/") {
+                            this.#currentPosition += 2;
+                            break;
+                        }
+                        this.#currentPosition++;
+                    }
+                    continue;
+                }
+            }
+            break;
+        }
+        this.#previousPosition = this.#currentPosition;
+    }
+}
+
 class ConfigFileOptionsWorker {
-    #compiler;
     #configFileOptionDefinitions;
     #configFileOptions;
-    #configFilePath;
+    #jsonScanner;
     #onDiagnostics;
     #optionGroup = 4;
     #optionValidator;
+    #sourceFile;
     #storeService;
-    constructor(compiler, configFileOptions, configFilePath, storeService, onDiagnostics) {
-        this.#compiler = compiler;
+    constructor(configFileOptions, sourceFile, storeService, onDiagnostics) {
         this.#configFileOptions = configFileOptions;
-        this.#configFilePath = configFilePath;
+        this.#sourceFile = sourceFile;
         this.#storeService = storeService;
         this.#onDiagnostics = onDiagnostics;
         this.#configFileOptionDefinitions = OptionDefinitionsMap.for(this.#optionGroup);
+        this.#jsonScanner = new JsonScanner(this.#sourceFile);
         this.#optionValidator = new OptionValidator(this.#optionGroup, this.#storeService, this.#onDiagnostics);
     }
-    #isDoubleQuotedString(node, sourceFile) {
-        return (node.kind === this.#compiler.SyntaxKind.StringLiteral &&
-            sourceFile.text.slice(this.#skipTrivia(node.pos, sourceFile), node.end).startsWith('"'));
-    }
-    async parse(sourceText) {
-        const sourceFile = this.#compiler.parseJsonText(this.#configFilePath, sourceText);
-        if (sourceFile.parseDiagnostics.length > 0) {
-            this.#onDiagnostics(Diagnostic.fromDiagnostics(sourceFile.parseDiagnostics, this.#compiler));
-            return;
-        }
-        const rootExpression = sourceFile.statements[0]?.expression;
-        if (!rootExpression) {
-            return;
-        }
-        if (!this.#compiler.isObjectLiteralExpression(rootExpression)) {
-            const origin = DiagnosticOrigin.fromJsonNode(rootExpression, sourceFile, this.#skipTrivia);
-            this.#onDiagnostics(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, sourceFile)) {
-                    const origin = DiagnosticOrigin.fromJsonNode(property.name, sourceFile, this.#skipTrivia);
-                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.doubleQuotesExpected(), origin));
-                    continue;
-                }
-                const optionName = property.name.text;
-                if (optionName === "$schema") {
-                    continue;
-                }
-                const optionDefinition = this.#configFileOptionDefinitions.get(optionName);
-                if (optionDefinition) {
-                    this.#configFileOptions[optionDefinition.name] = await this.#parseOptionValue(sourceFile, property.initializer, optionDefinition);
-                }
-                else {
-                    const origin = DiagnosticOrigin.fromJsonNode(property.name, sourceFile, this.#skipTrivia);
-                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.unknownOption(optionName), origin));
-                }
-            }
-        }
-        return;
+    #onRequiresValue(optionDefinition, jsonNode, isListItem) {
+        const text = isListItem
+            ? ConfigDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
+            : ConfigDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand, this.#optionGroup);
+        this.#onDiagnostics(Diagnostic.error(text, jsonNode.origin));
     }
-    async #parseOptionValue(sourceFile, valueExpression, optionDefinition, isListItem = false) {
-        switch (valueExpression.kind) {
-            case this.#compiler.SyntaxKind.TrueKeyword: {
-                if (optionDefinition.brand === "boolean") {
-                    return true;
+    async #parseValue(optionDefinition, isListItem = false) {
+        let jsonNode;
+        let optionValue;
+        switch (optionDefinition.brand) {
+            case "boolean": {
+                jsonNode = this.#jsonScanner.read();
+                optionValue = jsonNode.getValue();
+                if (typeof optionValue !== "boolean") {
+                    this.#onRequiresValue(optionDefinition, jsonNode, isListItem);
+                    break;
                 }
                 break;
             }
-            case this.#compiler.SyntaxKind.FalseKeyword: {
-                if (optionDefinition.brand === "boolean") {
-                    return false;
+            case "string": {
+                jsonNode = this.#jsonScanner.read();
+                optionValue = jsonNode.getValue();
+                if (typeof optionValue !== "string") {
+                    this.#onRequiresValue(optionDefinition, jsonNode, isListItem);
+                    break;
                 }
+                if (optionDefinition.name === "rootPath") {
+                    optionValue = Path.resolve(Path.dirname(this.#sourceFile.fileName), optionValue);
+                }
+                await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand, jsonNode.origin);
                 break;
             }
-            case this.#compiler.SyntaxKind.StringLiteral: {
-                if (!this.#isDoubleQuotedString(valueExpression, sourceFile)) {
-                    const origin = DiagnosticOrigin.fromJsonNode(valueExpression, sourceFile, this.#skipTrivia);
-                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.doubleQuotesExpected(), origin));
-                    return;
+            case "list": {
+                const leftBracketToken = this.#jsonScanner.readToken("[");
+                if (!leftBracketToken.text) {
+                    jsonNode = this.#jsonScanner.skip();
+                    this.#onRequiresValue(optionDefinition, jsonNode, isListItem);
+                    break;
                 }
-                if (optionDefinition.brand === "string") {
-                    let value = valueExpression.text;
-                    if (optionDefinition.name === "rootPath") {
-                        value = Path.resolve(Path.dirname(this.#configFilePath), value);
+                optionValue = [];
+                while (!this.#jsonScanner.isRead()) {
+                    if (this.#jsonScanner.peekToken("]")) {
+                        break;
                     }
-                    const origin = DiagnosticOrigin.fromJsonNode(valueExpression, sourceFile, this.#skipTrivia);
-                    await this.#optionValidator.check(optionDefinition.name, value, optionDefinition.brand, origin);
-                    return value;
-                }
-                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));
+                    const item = await this.#parseValue(optionDefinition.items, true);
+                    if (item != null) {
+                        optionValue.push(item);
+                    }
+                    const commaToken = this.#jsonScanner.readToken(",");
+                    if (!commaToken.text) {
+                        break;
                     }
-                    return value;
+                }
+                const rightBracketToken = this.#jsonScanner.readToken("]");
+                if (!rightBracketToken.text) {
+                    const text = ConfigDiagnosticText.expected("closing ']'");
+                    const relatedText = ConfigDiagnosticText.seen("opening '['");
+                    const diagnostic = Diagnostic.error(text, rightBracketToken.origin).add({
+                        related: [Diagnostic.error(relatedText, leftBracketToken.origin)],
+                    });
+                    this.#onDiagnostics(diagnostic);
                 }
                 break;
             }
         }
-        const text = isListItem
-            ? ConfigDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
-            : ConfigDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand, this.#optionGroup);
-        const origin = DiagnosticOrigin.fromJsonNode(valueExpression, sourceFile, this.#skipTrivia);
-        this.#onDiagnostics(Diagnostic.error(text, origin));
-        return;
+        return optionValue;
     }
-    #skipTrivia(position, sourceFile) {
-        const { text } = sourceFile.getSourceFile();
-        while (position < text.length) {
-            if (/\s/.test(text.charAt(position))) {
-                position++;
-                continue;
+    async #parseObject() {
+        const leftBraceToken = this.#jsonScanner.readToken("{");
+        if (this.#jsonScanner.isRead()) {
+            return;
+        }
+        if (!leftBraceToken.text) {
+            const text = ConfigDiagnosticText.expected("'{'");
+            this.#onDiagnostics(Diagnostic.error(text, leftBraceToken.origin));
+            return;
+        }
+        while (!this.#jsonScanner.isRead()) {
+            if (this.#jsonScanner.peekToken("}")) {
+                break;
             }
-            if (text.charAt(position) === "/") {
-                if (text.charAt(position + 1) === "/") {
-                    position += 2;
-                    while (position < text.length) {
-                        if (text.charAt(position) === "\n") {
-                            break;
-                        }
-                        position++;
-                    }
-                    continue;
+            const optionNameNode = this.#jsonScanner.read();
+            const optionName = optionNameNode.getValue({ expectsIdentifier: true });
+            if (!optionName) {
+                const text = ConfigDiagnosticText.expected("option name");
+                this.#onDiagnostics(Diagnostic.error(text, optionNameNode.origin));
+                return;
+            }
+            const optionDefinition = this.#configFileOptionDefinitions.get(optionName);
+            if (!optionDefinition) {
+                const text = ConfigDiagnosticText.unknownOption(optionName);
+                this.#onDiagnostics(Diagnostic.error(text, optionNameNode.origin));
+                if (this.#jsonScanner.readToken(":")) {
+                    this.#jsonScanner.skip();
                 }
-                if (text.charAt(position + 1) === "*") {
-                    position += 2;
-                    while (position < text.length) {
-                        if (text.charAt(position) === "*" && text.charAt(position + 1) === "/") {
-                            position += 2;
-                            break;
-                        }
-                        position++;
-                    }
-                    continue;
+                const commaToken = this.#jsonScanner.readToken(",");
+                if (!commaToken.text) {
+                    break;
                 }
-                position++;
                 continue;
             }
-            break;
+            if (this.#jsonScanner.peekToken(":")) {
+                this.#jsonScanner.readToken(":");
+            }
+            const parsedValue = await this.#parseValue(optionDefinition);
+            if (optionDefinition.name !== "$schema") {
+                this.#configFileOptions[optionDefinition.name] = parsedValue;
+            }
+            const commaToken = this.#jsonScanner.readToken(",");
+            if (!commaToken.text) {
+                break;
+            }
+        }
+        const rightBraceToken = this.#jsonScanner.readToken("}");
+        if (!rightBraceToken.text) {
+            const text = ConfigDiagnosticText.expected("closing '}'");
+            const relatedText = ConfigDiagnosticText.seen("opening '{'");
+            const diagnostic = Diagnostic.error(text, rightBraceToken.origin).add({
+                related: [Diagnostic.error(relatedText, leftBraceToken.origin)],
+            });
+            this.#onDiagnostics(diagnostic);
         }
-        return position;
+    }
+    async parse() {
+        await this.#parseObject();
     }
 }
 
@@ -1357,7 +1502,7 @@ class ConfigService {
     #configFilePath = Path.resolve(defaultOptions.rootPath, "./tstyche.config.json");
     #pathMatch = [];
     #onDiagnostics(diagnostics) {
-        EventEmitter.dispatch(["config:error", { diagnostics: Array.isArray(diagnostics) ? diagnostics : [diagnostics] }]);
+        EventEmitter.dispatch(["config:error", { diagnostics: [diagnostics] }]);
     }
     async parseCommandLine(commandLineArgs, storeService) {
         this.#commandLineOptions = {};
@@ -1379,12 +1524,9 @@ class ConfigService {
         const configFileText = await fs.readFile(this.#configFilePath, {
             encoding: "utf8",
         });
-        const compiler = await storeService.load(environmentOptions.typescriptPath != null ? "current" : "latest");
-        if (!compiler) {
-            return;
-        }
-        const configFileWorker = new ConfigFileOptionsWorker(compiler, this.#configFileOptions, this.#configFilePath, storeService, this.#onDiagnostics);
-        await configFileWorker.parse(configFileText);
+        const sourceFile = new SourceFile(this.#configFilePath, configFileText);
+        const configFileWorker = new ConfigFileOptionsWorker(this.#configFileOptions, sourceFile, storeService, this.#onDiagnostics);
+        await configFileWorker.parse();
     }
     resolveConfig() {
         return {
@@ -1406,6 +1548,7 @@ var OptionBrand;
     OptionBrand["BareTrue"] = "bareTrue";
     OptionBrand["List"] = "list";
 })(OptionBrand || (OptionBrand = {}));
+
 var OptionGroup;
 (function (OptionGroup) {
     OptionGroup[OptionGroup["CommandLine"] = 2] = "CommandLine";
@@ -1589,31 +1732,26 @@ class RunReporter extends Reporter {
     }
     handleEvent([eventName, payload]) {
         switch (eventName) {
-            case "run:start": {
+            case "run:start":
                 this.#isFileViewExpanded = payload.result.tasks.length === 1 && this.#resolvedConfig.watch !== true;
                 break;
-            }
-            case "store:adds": {
+            case "store:adds":
                 this.outputService.writeMessage(addsPackageText(payload.packageVersion, payload.packagePath));
                 this.#hasReportedAdds = true;
                 break;
-            }
-            case "store:error": {
+            case "store:error":
                 for (const diagnostic of payload.diagnostics) {
                     this.outputService.writeError(diagnosticText(diagnostic));
                 }
                 break;
-            }
-            case "target:start": {
+            case "target:start":
                 this.#fileCount = payload.result.tasks.length;
                 break;
-            }
-            case "target:end": {
+            case "target:end":
                 this.#currentCompilerVersion = undefined;
                 this.#currentProjectConfigFilePath = undefined;
                 break;
-            }
-            case "project:uses": {
+            case "project:uses":
                 if (this.#currentCompilerVersion !== payload.compilerVersion ||
                     this.#currentProjectConfigFilePath !== payload.projectConfigFilePath) {
                     this.outputService.writeMessage(usesCompilerText(payload.compilerVersion, payload.projectConfigFilePath, {
@@ -1624,28 +1762,24 @@ class RunReporter extends Reporter {
                     this.#currentProjectConfigFilePath = payload.projectConfigFilePath;
                 }
                 break;
-            }
-            case "project:error": {
+            case "project:error":
                 for (const diagnostic of payload.diagnostics) {
                     this.outputService.writeError(diagnosticText(diagnostic));
                 }
                 break;
-            }
-            case "task:start": {
+            case "task:start":
                 if (!this.#resolvedConfig.noInteractive) {
                     this.outputService.writeMessage(taskStatusText(payload.result.status, payload.result.task));
                 }
                 this.#fileCount--;
                 this.#hasReportedError = false;
                 break;
-            }
-            case "task:error": {
+            case "task:error":
                 for (const diagnostic of payload.diagnostics) {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
                 }
                 break;
-            }
-            case "task:end": {
+            case "task:end":
                 if (!this.#resolvedConfig.noInteractive) {
                     this.outputService.eraseLastLine();
                 }
@@ -1657,32 +1791,27 @@ class RunReporter extends Reporter {
                 }
                 this.#fileView.clear();
                 break;
-            }
-            case "describe:start": {
+            case "describe:start":
                 if (this.#isFileViewExpanded) {
                     this.#fileView.beginDescribe(payload.result.describe.name);
                 }
                 break;
-            }
-            case "describe:end": {
+            case "describe:end":
                 if (this.#isFileViewExpanded) {
                     this.#fileView.endDescribe();
                 }
                 break;
-            }
-            case "test:skip": {
+            case "test:skip":
                 if (this.#isFileViewExpanded) {
                     this.#fileView.addTest("skip", payload.result.test.name);
                 }
                 break;
-            }
-            case "test:todo": {
+            case "test:todo":
                 if (this.#isFileViewExpanded) {
                     this.#fileView.addTest("todo", payload.result.test.name);
                 }
                 break;
-            }
-            case "test:error": {
+            case "test:error":
                 if (this.#isFileViewExpanded) {
                     this.#fileView.addTest("fail", payload.result.test.name);
                 }
@@ -1690,26 +1819,22 @@ class RunReporter extends Reporter {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
                 }
                 break;
-            }
-            case "test:fail": {
+            case "test:fail":
                 if (this.#isFileViewExpanded) {
                     this.#fileView.addTest("fail", payload.result.test.name);
                 }
                 break;
-            }
-            case "test:pass": {
+            case "test:pass":
                 if (this.#isFileViewExpanded) {
                     this.#fileView.addTest("pass", payload.result.test.name);
                 }
                 break;
-            }
             case "expect:error":
-            case "expect:fail": {
+            case "expect:fail":
                 for (const diagnostic of payload.diagnostics) {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
                 }
                 break;
-            }
         }
     }
 }
@@ -1723,14 +1848,12 @@ class SetupReporter extends Reporter {
         if ("diagnostics" in payload) {
             for (const diagnostic of payload.diagnostics) {
                 switch (diagnostic.category) {
-                    case "error": {
+                    case "error":
                         this.outputService.writeError(diagnosticText(diagnostic));
                         break;
-                    }
-                    case "warning": {
+                    case "warning":
                         this.outputService.writeWarning(diagnosticText(diagnostic));
                         break;
-                    }
                 }
             }
         }
@@ -1739,20 +1862,17 @@ class SetupReporter extends Reporter {
 
 class SummaryReporter extends Reporter {
     handleEvent([eventName, payload]) {
-        switch (eventName) {
-            case "run:end": {
-                this.outputService.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;
-            }
+        if (eventName === "run:end") {
+            this.outputService.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,
+            }));
         }
     }
 }
@@ -1760,22 +1880,19 @@ class SummaryReporter extends Reporter {
 class WatchReporter extends Reporter {
     handleEvent([eventName, payload]) {
         switch (eventName) {
-            case "run:start": {
+            case "run:start":
                 this.outputService.clearTerminal();
                 break;
-            }
-            case "run:end": {
+            case "run:end":
                 this.outputService.writeMessage(watchUsageText());
                 break;
-            }
-            case "watch:error": {
+            case "watch:error":
                 this.outputService.clearTerminal();
                 for (const diagnostic of payload.diagnostics) {
                     this.outputService.writeError(diagnosticText(diagnostic));
                 }
                 this.outputService.writeMessage(waitingForFileChangesText());
                 break;
-            }
         }
     }
 }
@@ -2082,19 +2199,17 @@ class WatchService {
                 case "\u0004":
                 case "\u001B":
                 case "q":
-                case "x": {
+                case "x":
                     onClose("watchClose");
                     break;
-                }
                 case "\u000D":
                 case "\u0020":
-                case "a": {
+                case "a":
                     debounce.clearTimeout();
-                    if (this.#watchedTestFiles.size !== 0) {
+                    if (this.#watchedTestFiles.size > 0) {
                         debounce.resolveWith([...this.#watchedTestFiles.values()]);
                     }
                     break;
-                }
             }
         };
         this.#inputService = new InputService(onInput);
@@ -2176,23 +2291,21 @@ class TestMember {
             return node.parent;
         };
         switch (this.brand) {
-            case "describe": {
+            case "describe":
                 for (const member of this.members) {
                     if (member.brand === "expect") {
                         diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(getParentCallExpression(member.node))));
                     }
                 }
                 break;
-            }
             case "test":
-            case "expect": {
+            case "expect":
                 for (const member of this.members) {
                     if (member.brand !== "expect") {
                         diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
                     }
                 }
                 break;
-            }
         }
         return diagnostics;
     }
@@ -2277,22 +2390,18 @@ class IdentifierLookup {
                 break;
             }
             switch (expression.name.getText()) {
-                case "fail": {
+                case "fail":
                     flags |= 1;
                     break;
-                }
-                case "only": {
+                case "only":
                     flags |= 2;
                     break;
-                }
-                case "skip": {
+                case "skip":
                     flags |= 4;
                     break;
-                }
-                case "todo": {
+                case "todo":
                     flags |= 8;
                     break;
-                }
             }
             expression = expression.expression;
         }
@@ -2403,6 +2512,7 @@ var TestMemberBrand;
     TestMemberBrand["Test"] = "test";
     TestMemberBrand["Expect"] = "expect";
 })(TestMemberBrand || (TestMemberBrand = {}));
+
 var TestMemberFlags;
 (function (TestMemberFlags) {
     TestMemberFlags[TestMemberFlags["None"] = 0] = "None";
@@ -3170,13 +3280,12 @@ class ExpectService {
             case "toBe":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-            case "toMatch": {
+            case "toMatch":
                 if (!assertion.target[0]) {
                     this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
                     return;
                 }
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
-            }
             case "toBeAny":
             case "toBeBigInt":
             case "toBeBoolean":
@@ -3188,27 +3297,26 @@ class ExpectService {
             case "toBeUndefined":
             case "toBeUniqueSymbol":
             case "toBeUnknown":
-            case "toBeVoid": {
+            case "toBeVoid":
                 return this[matcherNameText].match(matchWorker, assertion.source[0]);
-            }
-            case "toHaveProperty": {
+            case "toHaveProperty":
                 if (!assertion.target[0]) {
                     this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
-            }
-            case "toRaiseError": {
+            case "toRaiseError":
                 return this.toRaiseError.match(matchWorker, assertion.source[0], [...assertion.target], onDiagnostics);
-            }
-            default: {
-                const text = ExpectDiagnosticText.matcherIsNotSupported(matcherNameText);
-                const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
-                onDiagnostics(Diagnostic.error(text, origin));
-            }
+            default:
+                this.#onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics);
         }
         return;
     }
+    #onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics) {
+        const text = ExpectDiagnosticText.matcherIsNotSupported(matcherNameText);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        onDiagnostics(Diagnostic.error(text, origin));
+    }
     #onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("source", "Source");
         const origin = DiagnosticOrigin.fromNode(assertion.node.expression);
@@ -3275,18 +3383,15 @@ class TestTreeWorker {
                 break;
             }
             switch (member.brand) {
-                case "describe": {
+                case "describe":
                     this.#visitDescribe(member, runMode, parentResult);
                     break;
-                }
-                case "test": {
+                case "test":
                     this.#visitTest(member, runMode, parentResult);
                     break;
-                }
-                case "expect": {
+                case "expect":
                     this.#visitAssertion(member, runMode, parentResult);
                     break;
-                }
             }
         }
     }
@@ -3510,7 +3615,7 @@ class TSTyche {
     #runner;
     #selectService;
     #storeService;
-    static version = "3.0.0-beta.1";
+    static version = "3.0.0-beta.2";
     constructor(resolvedConfig, outputService, selectService, storeService) {
         this.#resolvedConfig = resolvedConfig;
         this.#outputService = outputService;
@@ -4052,7 +4157,7 @@ class Cli {
             }
             const selectService = new SelectService(resolvedConfig);
             let testFiles = [];
-            if (resolvedConfig.testFileMatch.length !== 0) {
+            if (resolvedConfig.testFileMatch.length > 0) {
                 testFiles = await selectService.selectFiles();
                 if (testFiles.length === 0) {
                     if (commandLineArguments.includes("--watch")) {
@@ -4103,4 +4208,4 @@ class Cli {
     }
 }
 
-export { Assertion, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, ConfigDiagnosticText, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, OptionBrand, OptionDefinitionsMap, OptionGroup, OutputService, Path, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, RunReporter, Runner, Scribbler, SelectDiagnosticText, SelectService, SetupReporter, StoreService, SummaryReporter, TSTyche, TargetResult, Task, TaskResult, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { Assertion, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, ConfigDiagnosticText, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, OptionBrand, OptionDefinitionsMap, OptionGroup, OutputService, Path, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, RunReporter, Runner, Scribbler, SelectDiagnosticText, SelectService, SetupReporter, SourceFile, StoreService, SummaryReporter, TSTyche, TargetResult, Task, TaskResult, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };