@codingame/monaco-vscode-api 5.3.0 → 6.0.1

package/vscode/src/vs/workbench/contrib/testing/common/testResult.js

@@ -16,7 +16,7 @@ import { ITelemetryService } from '../../../../platform/telemetry/common/telemet
 import { refreshComputedState } from './getComputedState.js';
 import { TestId } from './testId.js';
 import { makeEmptyCounts, terminalStatePriorities, maxPriority, statesInOrder } from './testingStates.js';
-import { TestResultItem, getMarkId } from './testTypes.js';
+import { TestResultItem, TestResultState, getMarkId, TestMessageType, TestItemExpandState } from './testTypes.js';
 const _moduleId = "vs/workbench/contrib/testing/common/testResult";
 const emptyRawOutput = {
     buffers: [],
@@ -72,6 +72,11 @@ class TaskRawOutput {
             this.push(data);
             return { offset, length };
         }
+        let TrimBytes;
+        ( ((function(TrimBytes) {
+            TrimBytes[TrimBytes["CR"] = 13] = "CR";
+            TrimBytes[TrimBytes["LF"] = 10] = "LF";
+        })(TrimBytes || (TrimBytes = {}))));
         const start = VSBuffer.fromString(getMarkCode(marker, true));
         const end = VSBuffer.fromString(getMarkCode(marker, false));
         length += start.byteLength + end.byteLength;
@@ -79,7 +84,7 @@ class TaskRawOutput {
         let trimLen = data.byteLength;
         for (; trimLen > 0; trimLen--) {
             const last = data.buffer[trimLen - 1];
-            if (last !== 13  && last !== 10 ) {
+            if (last !== TrimBytes.CR && last !== TrimBytes.LF) {
                 break;
             }
         }
@@ -111,18 +116,24 @@ const maxCountPriority = (counts) => {
             return state;
         }
     }
-    return 0 ;
+    return TestResultState.Unset;
 };
 const getMarkCode = (marker, start) => `\x1b]633;SetMark;Id=${getMarkId(marker, start)};Hidden\x07`;
 const itemToNode = (controllerId, item, parent) => ({
     controllerId,
-    expand: 0 ,
+    expand: TestItemExpandState.NotExpandable,
     item: { ...item },
     children: [],
     tasks: [],
-    ownComputedState: 0 ,
-    computedState: 0 ,
+    ownComputedState: TestResultState.Unset,
+    computedState: TestResultState.Unset,
 });
+var TestResultItemChangeReason;
+( ((function(TestResultItemChangeReason) {
+    TestResultItemChangeReason[TestResultItemChangeReason["ComputedStateChange"] = 0] = "ComputedStateChange";
+    TestResultItemChangeReason[TestResultItemChangeReason["OwnStateChange"] = 1] = "OwnStateChange";
+    TestResultItemChangeReason[TestResultItemChangeReason["NewMessage"] = 2] = "NewMessage";
+})(TestResultItemChangeReason || (TestResultItemChangeReason = {}))));
 let LiveTestResult = class LiveTestResult extends Disposable {
     get completedAt() {
         return this._completedAt;
@@ -132,6 +143,9 @@ let LiveTestResult = class LiveTestResult extends Disposable {
              (this.testById.values())
         );
     }
+    getTestById(id) {
+        return this.testById.get(id)?.item;
+    }
     constructor(id, persist, request, telemetry) {
         super();
         this.id = id;
@@ -209,12 +223,12 @@ let LiveTestResult = class LiveTestResult extends Disposable {
             offset,
             length,
             marker,
-            type: 1 ,
+            type: TestMessageType.Output,
         };
         const test = testId && this.testById.get(testId);
         if (test) {
             test.tasks[index].messages.push(message);
-            this.changeEmitter.fire({ item: test, result: this, reason: 2 , message });
+            this.changeEmitter.fire({ item: test, result: this, reason: TestResultItemChangeReason.NewMessage, message });
         }
         else {
             task.otherMessages.push(message);
@@ -223,7 +237,7 @@ let LiveTestResult = class LiveTestResult extends Disposable {
     addTask(task) {
         this.tasks.push({ ...task, coverage: observableValue(this, undefined), otherMessages: [], output: ( (new TaskRawOutput())) });
         for (const test of this.tests) {
-            test.tasks.push({ duration: undefined, messages: [], state: 0  });
+            test.tasks.push({ duration: undefined, messages: [], state: TestResultState.Unset });
         }
         this.newTaskEmitter.fire(this.tasks.length - 1);
     }
@@ -257,14 +271,14 @@ let LiveTestResult = class LiveTestResult extends Disposable {
             return;
         }
         entry.tasks[this.mustGetTaskIndex(taskId)].messages.push(message);
-        this.changeEmitter.fire({ item: entry, result: this, reason: 2 , message });
+        this.changeEmitter.fire({ item: entry, result: this, reason: TestResultItemChangeReason.NewMessage, message });
     }
     markTaskComplete(taskId) {
         const index = this.mustGetTaskIndex(taskId);
         const task = this.tasks[index];
         task.running = false;
         task.output.end();
-        this.setAllToState(0 , taskId, t => t.state === 1  || t.state === 2 );
+        this.setAllToState(TestResultState.Unset, taskId, t => t.state === TestResultState.Queued || t.state === TestResultState.Running);
         this.endTaskEmitter.fire(index);
     }
     markComplete() {
@@ -279,8 +293,8 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         this._completedAt = Date.now();
         this.completeEmitter.fire();
         this.telemetry.publicLog2('test.outcomes', {
-            failures: this.counts[6 ] + this.counts[4 ],
-            passes: this.counts[3 ],
+            failures: this.counts[TestResultState.Errored] + this.counts[TestResultState.Failed],
+            passes: this.counts[TestResultState.Passed],
             controller: ( (this.request.targets.map(t => t.controllerId))).join(',')
         });
     }
@@ -288,7 +302,7 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         for (const [id, test] of this.testById) {
             if (!test.retired && (!testIds || testIds.hasKeyOrParent(TestId.fromString(id).path))) {
                 test.retired = true;
-                this.changeEmitter.fire({ reason: 0 , item: test, result: this });
+                this.changeEmitter.fire({ reason: TestResultItemChangeReason.ComputedStateChange, item: test, result: this });
             }
         }
     }
@@ -312,7 +326,7 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         const changeEvent = {
             item: entry,
             result: this,
-            reason: 1 ,
+            reason: TestResultItemChangeReason.OwnStateChange,
             previousState: previousOwnComputed,
             previousOwnDuration: previousOwnDuration,
         };
@@ -334,19 +348,19 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         refreshComputedState(this.computedStateAccessor, entry).forEach(t => this.changeEmitter.fire(t === entry ? changeEvent : {
             item: t,
             result: this,
-            reason: 0 ,
+            reason: TestResultItemChangeReason.ComputedStateChange,
         }));
     }
     addTestToRun(controllerId, item, parent) {
         const node = itemToNode(controllerId, item);
         this.testById.set(item.extId, node);
-        this.counts[0 ]++;
+        this.counts[TestResultState.Unset]++;
         if (parent) {
             this.testById.get(parent)?.children.push(node);
         }
         if (this.tasks.length) {
             for (let i = 0; i < this.tasks.length; i++) {
-                node.tasks.push({ duration: undefined, messages: [], state: 0  });
+                node.tasks.push({ duration: undefined, messages: [], state: TestResultState.Unset });
             }
         }
         return node;
@@ -401,4 +415,4 @@ class HydratedTestResult {
         return this.toJSON();
     }
 }
-export { HydratedTestResult, LiveTestResult, TaskRawOutput, maxCountPriority, resultItemParents };
+export { HydratedTestResult, LiveTestResult, TaskRawOutput, TestResultItemChangeReason, maxCountPriority, resultItemParents };

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.js

@@ -2,22 +2,47 @@ import { URI } from '../../../../base/common/uri.js';
 import { Position } from '../../../../editor/common/core/position.js';
 import { Range } from '../../../../editor/common/core/range.js';
 import { TestId } from './testId.js';
+var TestResultState;
+( (function(TestResultState) {
+    TestResultState[TestResultState["Unset"] = 0] = "Unset";
+    TestResultState[TestResultState["Queued"] = 1] = "Queued";
+    TestResultState[TestResultState["Running"] = 2] = "Running";
+    TestResultState[TestResultState["Passed"] = 3] = "Passed";
+    TestResultState[TestResultState["Failed"] = 4] = "Failed";
+    TestResultState[TestResultState["Skipped"] = 5] = "Skipped";
+    TestResultState[TestResultState["Errored"] = 6] = "Errored";
+})(TestResultState || (TestResultState = {})));
 const testResultStateToContextValues = {
-    [0 ]: 'unset',
-    [1 ]: 'queued',
-    [2 ]: 'running',
-    [3 ]: 'passed',
-    [4 ]: 'failed',
-    [5 ]: 'skipped',
-    [6 ]: 'errored',
+    [TestResultState.Unset]: 'unset',
+    [TestResultState.Queued]: 'queued',
+    [TestResultState.Running]: 'running',
+    [TestResultState.Passed]: 'passed',
+    [TestResultState.Failed]: 'failed',
+    [TestResultState.Skipped]: 'skipped',
+    [TestResultState.Errored]: 'errored',
 };
+var ExtTestRunProfileKind;
+( (function(ExtTestRunProfileKind) {
+    ExtTestRunProfileKind[ExtTestRunProfileKind["Run"] = 1] = "Run";
+    ExtTestRunProfileKind[ExtTestRunProfileKind["Debug"] = 2] = "Debug";
+    ExtTestRunProfileKind[ExtTestRunProfileKind["Coverage"] = 3] = "Coverage";
+})(ExtTestRunProfileKind || (ExtTestRunProfileKind = {})));
+var TestRunProfileBitset;
+( (function(TestRunProfileBitset) {
+    TestRunProfileBitset[TestRunProfileBitset["Run"] = 2] = "Run";
+    TestRunProfileBitset[TestRunProfileBitset["Debug"] = 4] = "Debug";
+    TestRunProfileBitset[TestRunProfileBitset["Coverage"] = 8] = "Coverage";
+    TestRunProfileBitset[TestRunProfileBitset["HasNonDefaultProfile"] = 16] = "HasNonDefaultProfile";
+    TestRunProfileBitset[TestRunProfileBitset["HasConfigurable"] = 32] = "HasConfigurable";
+    TestRunProfileBitset[TestRunProfileBitset["SupportsContinuousRun"] = 64] = "SupportsContinuousRun";
+})(TestRunProfileBitset || (TestRunProfileBitset = {})));
 const testRunProfileBitsetList = [
-    2 ,
-    4 ,
-    8 ,
-    16 ,
-    32 ,
-    64 ,
+    TestRunProfileBitset.Run,
+    TestRunProfileBitset.Debug,
+    TestRunProfileBitset.Coverage,
+    TestRunProfileBitset.HasNonDefaultProfile,
+    TestRunProfileBitset.HasConfigurable,
+    TestRunProfileBitset.SupportsContinuousRun,
 ];
 const isStartControllerTests = (t) => 'runId' in t;
 var IRichLocation;
@@ -31,11 +56,16 @@ var IRichLocation;
         uri: uriIdentity.asCanonicalUri(URI.revive(location.uri)),
     });
 })(IRichLocation || (IRichLocation = {})));
+var TestMessageType;
+( (function(TestMessageType) {
+    TestMessageType[TestMessageType["Error"] = 0] = "Error";
+    TestMessageType[TestMessageType["Output"] = 1] = "Output";
+})(TestMessageType || (TestMessageType = {})));
 var ITestErrorMessage;
 ( (function(ITestErrorMessage) {
     ITestErrorMessage.serialize = (message) => ({
         message: message.message,
-        type: 0 ,
+        type: TestMessageType.Error,
         expected: message.expected,
         actual: message.actual,
         contextValue: message.contextValue,
@@ -43,7 +73,7 @@ var ITestErrorMessage;
     });
     ITestErrorMessage.deserialize = (uriIdentity, message) => ({
         message: message.message,
-        type: 0 ,
+        type: TestMessageType.Error,
         expected: message.expected,
         actual: message.actual,
         contextValue: message.contextValue,
@@ -55,14 +85,14 @@ var ITestOutputMessage;
 ( (function(ITestOutputMessage) {
     ITestOutputMessage.serialize = (message) => ({
         message: message.message,
-        type: 1 ,
+        type: TestMessageType.Output,
         offset: message.offset,
         length: message.length,
         location: message.location && IRichLocation.serialize(message.location),
     });
     ITestOutputMessage.deserialize = (uriIdentity, message) => ({
         message: message.message,
-        type: 1 ,
+        type: TestMessageType.Output,
         offset: message.offset,
         length: message.length,
         location: message.location && IRichLocation.deserialize(uriIdentity, message.location),
@@ -70,8 +100,8 @@ var ITestOutputMessage;
 })(ITestOutputMessage || (ITestOutputMessage = {})));
 var ITestMessage;
 ( (function(ITestMessage) {
-    ITestMessage.serialize = (message) => message.type === 0  ? ITestErrorMessage.serialize(message) : ITestOutputMessage.serialize(message);
-    ITestMessage.deserialize = (uriIdentity, message) => message.type === 0  ? ITestErrorMessage.deserialize(uriIdentity, message) : ITestOutputMessage.deserialize(uriIdentity, message);
+    ITestMessage.serialize = (message) => message.type === TestMessageType.Error ? ITestErrorMessage.serialize(message) : ITestOutputMessage.serialize(message);
+    ITestMessage.deserialize = (uriIdentity, message) => message.type === TestMessageType.Error ? ITestErrorMessage.deserialize(uriIdentity, message) : ITestOutputMessage.deserialize(uriIdentity, message);
 })(ITestMessage || (ITestMessage = {})));
 var ITestTaskState;
 ( (function(ITestTaskState) {
@@ -124,6 +154,13 @@ var ITestItem;
         sortText: serialized.sortText
     });
 })(ITestItem || (ITestItem = {})));
+var TestItemExpandState;
+( (function(TestItemExpandState) {
+    TestItemExpandState[TestItemExpandState["NotExpandable"] = 0] = "NotExpandable";
+    TestItemExpandState[TestItemExpandState["Expandable"] = 1] = "Expandable";
+    TestItemExpandState[TestItemExpandState["BusyExpanding"] = 2] = "BusyExpanding";
+    TestItemExpandState[TestItemExpandState["Expanded"] = 3] = "Expanded";
+})(TestItemExpandState || (TestItemExpandState = {})));
 var InternalTestItem;
 ( (function(InternalTestItem) {
     InternalTestItem.serialize = (item) => ({
@@ -228,6 +265,14 @@ var TestResultItem;
         retired: true,
     });
 })(TestResultItem || (TestResultItem = {})));
+var ICoverageCount;
+( (function(ICoverageCount) {
+    ICoverageCount.empty = () => ({ covered: 0, total: 0 });
+    ICoverageCount.sum = (target, src) => {
+        target.covered += src.covered;
+        target.total += src.total;
+    };
+})(ICoverageCount || (ICoverageCount = {})));
 var IFileCoverage;
 ( (function(IFileCoverage) {
     IFileCoverage.serialize = (original) => ({
@@ -235,6 +280,7 @@ var IFileCoverage;
         statement: original.statement,
         branch: original.branch,
         declaration: original.declaration,
+        testId: original.testId?.toString(),
         uri: original.uri.toJSON(),
     });
     IFileCoverage.deserialize = (uriIdentity, serialized) => ({
@@ -242,8 +288,15 @@ var IFileCoverage;
         statement: serialized.statement,
         branch: serialized.branch,
         declaration: serialized.declaration,
+        testId: serialized.testId ? TestId.fromString(serialized.testId) : undefined,
         uri: uriIdentity.asCanonicalUri(URI.revive(serialized.uri)),
     });
+    IFileCoverage.empty = (id, uri) => ({
+        id,
+        uri,
+        testId: undefined,
+        statement: ICoverageCount.empty(),
+    });
 })(IFileCoverage || (IFileCoverage = {})));
 function serializeThingWithLocation(serialized) {
     return {
@@ -255,10 +308,16 @@ function deserializeThingWithLocation(serialized) {
     serialized.location = serialized.location ? (Position.isIPosition(serialized.location) ? Position.lift(serialized.location) : Range.lift(serialized.location)) : undefined;
     return serialized;
 }
+var DetailType;
+( (function(DetailType) {
+    DetailType[DetailType["Declaration"] = 0] = "Declaration";
+    DetailType[DetailType["Statement"] = 1] = "Statement";
+    DetailType[DetailType["Branch"] = 2] = "Branch";
+})(DetailType || (DetailType = {})));
 var CoverageDetails;
 ( (function(CoverageDetails) {
-    CoverageDetails.serialize = (original) => original.type === 0  ? IDeclarationCoverage.serialize(original) : IStatementCoverage.serialize(original);
-    CoverageDetails.deserialize = (serialized) => serialized.type === 0  ? IDeclarationCoverage.deserialize(serialized) : IStatementCoverage.deserialize(serialized);
+    CoverageDetails.serialize = (original) => original.type === DetailType.Declaration ? IDeclarationCoverage.serialize(original) : IStatementCoverage.serialize(original);
+    CoverageDetails.deserialize = (serialized) => serialized.type === DetailType.Declaration ? IDeclarationCoverage.deserialize(serialized) : IStatementCoverage.deserialize(serialized);
 })(CoverageDetails || (CoverageDetails = {})));
 var IBranchCoverage;
 ( (function(IBranchCoverage) {
@@ -281,16 +340,27 @@ var IStatementCoverage;
         branches: serialized.branches?.map(IBranchCoverage.deserialize),
     });
 })(IStatementCoverage || (IStatementCoverage = {})));
+var TestDiffOpType;
+( (function(TestDiffOpType) {
+    TestDiffOpType[TestDiffOpType["Add"] = 0] = "Add";
+    TestDiffOpType[TestDiffOpType["Update"] = 1] = "Update";
+    TestDiffOpType[TestDiffOpType["DocumentSynced"] = 2] = "DocumentSynced";
+    TestDiffOpType[TestDiffOpType["Remove"] = 3] = "Remove";
+    TestDiffOpType[TestDiffOpType["IncrementPendingExtHosts"] = 4] = "IncrementPendingExtHosts";
+    TestDiffOpType[TestDiffOpType["Retire"] = 5] = "Retire";
+    TestDiffOpType[TestDiffOpType["AddTag"] = 6] = "AddTag";
+    TestDiffOpType[TestDiffOpType["RemoveTag"] = 7] = "RemoveTag";
+})(TestDiffOpType || (TestDiffOpType = {})));
 var TestsDiffOp;
 ( (function(TestsDiffOp) {
     TestsDiffOp.deserialize = (uriIdentity, u) => {
-        if (u.op === 0 ) {
+        if (u.op === TestDiffOpType.Add) {
             return { op: u.op, item: InternalTestItem.deserialize(uriIdentity, u.item) };
         }
-        else if (u.op === 1 ) {
+        else if (u.op === TestDiffOpType.Update) {
             return { op: u.op, item: ITestItemUpdate.deserialize(u.item) };
         }
-        else if (u.op === 2 ) {
+        else if (u.op === TestDiffOpType.DocumentSynced) {
             return { op: u.op, uri: uriIdentity.asCanonicalUri(URI.revive(u.uri)), docv: u.docv };
         }
         else {
@@ -298,10 +368,10 @@ var TestsDiffOp;
         }
     };
     TestsDiffOp.serialize = (u) => {
-        if (u.op === 0 ) {
+        if (u.op === TestDiffOpType.Add) {
             return { op: u.op, item: InternalTestItem.serialize(u.item) };
         }
-        else if (u.op === 1 ) {
+        else if (u.op === TestDiffOpType.Update) {
             return { op: u.op, item: ITestItemUpdate.serialize(u.item) };
         }
         else {
@@ -323,25 +393,25 @@ class AbstractIncrementalTestCollection {
         const changes = this.createChangeCollector();
         for (const op of diff) {
             switch (op.op) {
-                case 0 :
+                case TestDiffOpType.Add:
                     this.add(InternalTestItem.deserialize(this.uriIdentity, op.item), changes);
                     break;
-                case 1 :
+                case TestDiffOpType.Update:
                     this.update(ITestItemUpdate.deserialize(op.item), changes);
                     break;
-                case 3 :
+                case TestDiffOpType.Remove:
                     this.remove(op.itemId, changes);
                     break;
-                case 5 :
+                case TestDiffOpType.Retire:
                     this.retireTest(op.itemId);
                     break;
-                case 4 :
+                case TestDiffOpType.IncrementPendingExtHosts:
                     this.updatePendingRoots(op.amount);
                     break;
-                case 6 :
+                case TestDiffOpType.AddTag:
                     this._tags.set(op.tag.id, op.tag);
                     break;
-                case 7 :
+                case TestDiffOpType.RemoveTag:
                     this._tags.delete(op.id);
                     break;
             }
@@ -367,7 +437,7 @@ class AbstractIncrementalTestCollection {
             return;
         }
         changes.add?.(created);
-        if (item.expand === 2 ) {
+        if (item.expand === TestItemExpandState.BusyExpanding) {
             this.busyControllerCount++;
         }
         return created;
@@ -378,10 +448,10 @@ class AbstractIncrementalTestCollection {
             return;
         }
         if (patch.expand !== undefined) {
-            if (existing.expand === 2 ) {
+            if (existing.expand === TestItemExpandState.BusyExpanding) {
                 this.busyControllerCount--;
             }
-            if (patch.expand === 2 ) {
+            if (patch.expand === TestItemExpandState.BusyExpanding) {
                 this.busyControllerCount++;
             }
         }
@@ -410,7 +480,7 @@ class AbstractIncrementalTestCollection {
                     queue.push(existing.children);
                     this.items.delete(itemId);
                     changes.remove?.(existing, existing !== toRemove);
-                    if (existing.expand === 2 ) {
+                    if (existing.expand === TestItemExpandState.BusyExpanding) {
                         this.busyControllerCount--;
                     }
                 }
@@ -426,4 +496,4 @@ class AbstractIncrementalTestCollection {
         return {};
     }
 }
-export { AbstractIncrementalTestCollection, CoverageDetails, IBranchCoverage, IDeclarationCoverage, IFileCoverage, IRichLocation, IStatementCoverage, ITestErrorMessage, ITestItem, ITestItemUpdate, ITestMessage, ITestOutputMessage, ITestTaskState, InternalTestItem, TestResultItem, TestsDiffOp, applyTestItemUpdate, denamespaceTestTag, getMarkId, isStartControllerTests, namespaceTestTag, testResultStateToContextValues, testRunProfileBitsetList };
+export { AbstractIncrementalTestCollection, CoverageDetails, DetailType, ExtTestRunProfileKind, IBranchCoverage, ICoverageCount, IDeclarationCoverage, IFileCoverage, IRichLocation, IStatementCoverage, ITestErrorMessage, ITestItem, ITestItemUpdate, ITestMessage, ITestOutputMessage, ITestTaskState, InternalTestItem, TestDiffOpType, TestItemExpandState, TestMessageType, TestResultItem, TestResultState, TestRunProfileBitset, TestsDiffOp, applyTestItemUpdate, denamespaceTestTag, getMarkId, isStartControllerTests, namespaceTestTag, testResultStateToContextValues, testRunProfileBitsetList };

package/vscode/src/vs/workbench/contrib/testing/common/testingStates.js

@@ -1,24 +1,25 @@
+import { mapValues } from '../../../../base/common/objects.js';
+import { TestResultState } from './testTypes.js';
 const statePriority = {
-    [2 ]: 6,
-    [6 ]: 5,
-    [4 ]: 4,
-    [1 ]: 3,
-    [3 ]: 2,
-    [0 ]: 0,
-    [5 ]: 1,
+    [TestResultState.Running]: 6,
+    [TestResultState.Errored]: 5,
+    [TestResultState.Failed]: 4,
+    [TestResultState.Queued]: 3,
+    [TestResultState.Passed]: 2,
+    [TestResultState.Unset]: 0,
+    [TestResultState.Skipped]: 1,
 };
-const isFailedState = (s) => s === 6  || s === 4 ;
-const isStateWithResult = (s) => s === 6  || s === 4  || s === 3 ;
-Object.entries(statePriority).reduce((acc, [stateStr, priority]) => {
+const isFailedState = (s) => s === TestResultState.Errored || s === TestResultState.Failed;
+const isStateWithResult = (s) => s === TestResultState.Errored || s === TestResultState.Failed || s === TestResultState.Passed;
+mapValues(statePriority, (priority, stateStr) => {
     const state = Number(stateStr);
-    acc[state] = { statusNode: true, state, priority };
-    return acc;
-}, {});
+    return { statusNode: true, state, priority };
+});
 const cmpPriority = (a, b) => statePriority[b] - statePriority[a];
 const maxPriority = (...states) => {
     switch (states.length) {
         case 0:
-            return 0 ;
+            return TestResultState.Unset;
         case 1:
             return states[0];
         case 2:
@@ -36,10 +37,10 @@ const maxPriority = (...states) => {
 };
 const statesInOrder = ( ( Object.keys(statePriority)).map(s => Number(s))).sort(cmpPriority);
 const terminalStatePriorities = {
-    [3 ]: 0,
-    [5 ]: 1,
-    [4 ]: 2,
-    [6 ]: 3,
+    [TestResultState.Passed]: 0,
+    [TestResultState.Skipped]: 1,
+    [TestResultState.Failed]: 2,
+    [TestResultState.Errored]: 3,
 };
 const makeEmptyCounts = () => {
     return ( new Uint32Array(statesInOrder.length));

package/vscode/src/vs/workbench/contrib/timeline/common/timeline.js

@@ -1,5 +1,4 @@
-import '../../../../base/common/strings.js';
-import '../../../../base/common/network.js';
+import '../../../../platform/extensions/common/extensions.js';
 const TimelinePaneId = 'timeline';
 const TIMELINE_SERVICE_ID = 'timeline';
 export { TIMELINE_SERVICE_ID, TimelinePaneId };

package/vscode/src/vs/workbench/contrib/typeHierarchy/common/typeHierarchy.js

@@ -10,6 +10,11 @@ import { CommandsRegistry } from '../../../../platform/commands/common/commands.
 import { assertType } from '../../../../base/common/types.js';
 import { IModelService } from '../../../../editor/common/services/model.js';
 import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+var TypeHierarchyDirection;
+( (function(TypeHierarchyDirection) {
+    TypeHierarchyDirection["Subtypes"] = "subtypes";
+    TypeHierarchyDirection["Supertypes"] = "supertypes";
+})(TypeHierarchyDirection || (TypeHierarchyDirection = {})));
 const TypeHierarchyProviderRegistry = ( new LanguageFeatureRegistry());
 class TypeHierarchyModel {
     static async create(model, position, token) {
@@ -130,4 +135,4 @@ CommandsRegistry.registerCommand('_executeProvideSubtypes', async (_accessor, ..
     }
     return model.provideSubtypes(item, CancellationToken.None);
 });
-export { TypeHierarchyModel, TypeHierarchyProviderRegistry };
+export { TypeHierarchyDirection, TypeHierarchyModel, TypeHierarchyProviderRegistry };

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomainService.js

@@ -0,0 +1,77 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { WindowIdleValue } from '../../../../base/browser/dom.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { StorageScope } from '../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { TRUSTED_DOMAINS_STORAGE_KEY, readStaticTrustedDomains } from './trustedDomains.js';
+import { testUrlMatchesGlob } from '../common/urlGlob.js';
+let TrustedDomainService = class TrustedDomainService extends Disposable {
+    constructor(_instantiationService, _storageService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._storageService = _storageService;
+        const initStaticDomainsResult = () => {
+            return ( new WindowIdleValue(mainWindow, () => {
+                const { defaultTrustedDomains, trustedDomains, } = this._instantiationService.invokeFunction(readStaticTrustedDomains);
+                return [
+                    ...defaultTrustedDomains,
+                    ...trustedDomains
+                ];
+            }));
+        };
+        this._staticTrustedDomainsResult = initStaticDomainsResult();
+        this._register(this._storageService.onDidChangeValue(StorageScope.APPLICATION, TRUSTED_DOMAINS_STORAGE_KEY, this._register(( new DisposableStore())))(() => {
+            this._staticTrustedDomainsResult?.dispose();
+            this._staticTrustedDomainsResult = initStaticDomainsResult();
+        }));
+    }
+    isValid(resource) {
+        const { defaultTrustedDomains, trustedDomains, } = this._instantiationService.invokeFunction(readStaticTrustedDomains);
+        const allTrustedDomains = [...defaultTrustedDomains, ...trustedDomains];
+        return isURLDomainTrusted(resource, allTrustedDomains);
+    }
+};
+TrustedDomainService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IStorageService))
+], TrustedDomainService));
+const rLocalhost = /^localhost(:\d+)?$/i;
+const r127 = /^127.0.0.1(:\d+)?$/;
+function isLocalhostAuthority(authority) {
+    return rLocalhost.test(authority) || r127.test(authority);
+}
+function normalizeURL(url) {
+    const caseInsensitiveAuthorities = ['github.com'];
+    try {
+        const parsed = typeof url === 'string' ? ( URI.parse(url, true)) : url;
+        if (caseInsensitiveAuthorities.includes(parsed.authority)) {
+            return ( parsed.with({ path: parsed.path.toLowerCase() }).toString(true));
+        }
+        else {
+            return ( parsed.toString(true));
+        }
+    }
+    catch {
+        return ( url.toString());
+    }
+}
+function isURLDomainTrusted(url, trustedDomains) {
+    url = ( URI.parse(normalizeURL(url)));
+    trustedDomains = ( trustedDomains.map(normalizeURL));
+    if (isLocalhostAuthority(url.authority)) {
+        return true;
+    }
+    for (let i = 0; i < trustedDomains.length; i++) {
+        if (trustedDomains[i] === '*') {
+            return true;
+        }
+        if (testUrlMatchesGlob(url, trustedDomains[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+export { TrustedDomainService, isURLDomainTrusted };

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomainService.service.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+const ITrustedDomainService = ( createDecorator('ITrustedDomainService'));
+export { ITrustedDomainService };