@codingame/monaco-vscode-api 23.3.0 → 24.1.0

package/vscode/src/vs/workbench/contrib/terminalContrib/typeAhead/common/terminalTypeAheadConfiguration.js

@@ -0,0 +1,71 @@
+
+import { localize } from '../../../../../nls.js';
+
+const DEFAULT_LOCAL_ECHO_EXCLUDE = ['vim', 'vi', 'nano', 'tmux'];
+var TerminalTypeAheadSettingId;
+(function (TerminalTypeAheadSettingId) {
+    TerminalTypeAheadSettingId["LocalEchoLatencyThreshold"] = "terminal.integrated.localEchoLatencyThreshold";
+    TerminalTypeAheadSettingId["LocalEchoEnabled"] = "terminal.integrated.localEchoEnabled";
+    TerminalTypeAheadSettingId["LocalEchoExcludePrograms"] = "terminal.integrated.localEchoExcludePrograms";
+    TerminalTypeAheadSettingId["LocalEchoStyle"] = "terminal.integrated.localEchoStyle";
+})(TerminalTypeAheadSettingId || (TerminalTypeAheadSettingId = {}));
+const terminalTypeAheadConfiguration = {
+    [TerminalTypeAheadSettingId.LocalEchoLatencyThreshold]: {
+        description: ( localize(
+            12327,
+            "Length of network delay, in milliseconds, where local edits will be echoed on the terminal without waiting for server acknowledgement. If '0', local echo will always be on, and if '-1' it will be disabled."
+        )),
+        type: 'integer',
+        minimum: -1,
+        default: 30,
+        tags: ['preview'],
+    },
+    [TerminalTypeAheadSettingId.LocalEchoEnabled]: {
+        markdownDescription: ( localize(
+            12328,
+            "When local echo should be enabled. This will override {0}",
+            '`#terminal.integrated.localEchoLatencyThreshold#`'
+        )),
+        type: 'string',
+        enum: ['on', 'off', 'auto'],
+        enumDescriptions: [
+            ( localize(12329, "Always enabled")),
+            ( localize(12330, "Always disabled")),
+            ( localize(12331, "Enabled only for remote workspaces"))
+        ],
+        default: 'off',
+        tags: ['preview'],
+    },
+    [TerminalTypeAheadSettingId.LocalEchoExcludePrograms]: {
+        description: ( localize(
+            12332,
+            "Local echo will be disabled when any of these program names are found in the terminal title."
+        )),
+        type: 'array',
+        items: {
+            type: 'string',
+            uniqueItems: true
+        },
+        default: DEFAULT_LOCAL_ECHO_EXCLUDE,
+        tags: ['preview'],
+    },
+    [TerminalTypeAheadSettingId.LocalEchoStyle]: {
+        description: ( localize(
+            12333,
+            "Terminal style of locally echoed text; either a font style or an RGB color."
+        )),
+        default: 'dim',
+        anyOf: [
+            {
+                enum: ['bold', 'dim', 'italic', 'underlined', 'inverted', '#ff0000'],
+            },
+            {
+                type: 'string',
+                format: 'color-hex',
+            }
+        ],
+        tags: ['preview'],
+    },
+};
+
+export { DEFAULT_LOCAL_ECHO_EXCLUDE, TerminalTypeAheadSettingId, terminalTypeAheadConfiguration };

package/vscode/src/vs/workbench/contrib/terminalContrib/zoom/common/terminal.zoom.d.ts

@@ -0,0 +1,11 @@
+import type { IStringDictionary } from "../../../../../base/common/collections.js";
+import type { IConfigurationPropertySchema } from "../../../../../platform/configuration/common/configurationRegistry.js";
+export declare enum TerminalZoomCommandId {
+    FontZoomIn = "workbench.action.terminal.fontZoomIn",
+    FontZoomOut = "workbench.action.terminal.fontZoomOut",
+    FontZoomReset = "workbench.action.terminal.fontZoomReset"
+}
+export declare enum TerminalZoomSettingId {
+    MouseWheelZoom = "terminal.integrated.mouseWheelZoom"
+}
+export declare const terminalZoomConfiguration: IStringDictionary<IConfigurationPropertySchema>;

package/vscode/src/vs/workbench/contrib/terminalContrib/zoom/common/terminal.zoom.js

@@ -0,0 +1,31 @@
+
+import { isMacintosh } from '../../../../../base/common/platform.js';
+import { localize } from '../../../../../nls.js';
+
+var TerminalZoomCommandId;
+(function (TerminalZoomCommandId) {
+    TerminalZoomCommandId["FontZoomIn"] = "workbench.action.terminal.fontZoomIn";
+    TerminalZoomCommandId["FontZoomOut"] = "workbench.action.terminal.fontZoomOut";
+    TerminalZoomCommandId["FontZoomReset"] = "workbench.action.terminal.fontZoomReset";
+})(TerminalZoomCommandId || (TerminalZoomCommandId = {}));
+var TerminalZoomSettingId;
+(function (TerminalZoomSettingId) {
+    TerminalZoomSettingId["MouseWheelZoom"] = "terminal.integrated.mouseWheelZoom";
+})(TerminalZoomSettingId || (TerminalZoomSettingId = {}));
+const terminalZoomConfiguration = {
+    [TerminalZoomSettingId.MouseWheelZoom]: {
+        markdownDescription: isMacintosh
+            ? ( localize(
+            12347,
+            "Zoom the font of the terminal when using mouse wheel and holding `Cmd`."
+        ))
+            : ( localize(
+            12348,
+            "Zoom the font of the terminal when using mouse wheel and holding `Ctrl`."
+        )),
+        type: 'boolean',
+        default: false
+    },
+};
+
+export { TerminalZoomCommandId, TerminalZoomSettingId, terminalZoomConfiguration };

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

@@ -27,19 +27,19 @@ var TestExplorerViewSorting;
     TestExplorerViewSorting["ByDuration"] = "duration";
 })(TestExplorerViewSorting || (TestExplorerViewSorting = {}));
 const testStateNames = {
-    [TestResultState.Errored]: ( localize(12516, 'Errored')),
-    [TestResultState.Failed]: ( localize(12517, 'Failed')),
-    [TestResultState.Passed]: ( localize(12518, 'Passed')),
-    [TestResultState.Queued]: ( localize(12519, 'Queued')),
-    [TestResultState.Running]: ( localize(12520, 'Running')),
-    [TestResultState.Skipped]: ( localize(12521, 'Skipped')),
-    [TestResultState.Unset]: ( localize(12522, 'Not yet run')),
+    [TestResultState.Errored]: ( localize(12656, 'Errored')),
+    [TestResultState.Failed]: ( localize(12657, 'Failed')),
+    [TestResultState.Passed]: ( localize(12658, 'Passed')),
+    [TestResultState.Queued]: ( localize(12659, 'Queued')),
+    [TestResultState.Running]: ( localize(12660, 'Running')),
+    [TestResultState.Skipped]: ( localize(12661, 'Skipped')),
+    [TestResultState.Unset]: ( localize(12662, 'Not yet run')),
 };
-const labelForTestInState = (label, state) => ( localize(12523, '{0} ({1})', stripIcons(label), testStateNames[state]));
+const labelForTestInState = (label, state) => ( localize(12663, '{0} ({1})', stripIcons(label), testStateNames[state]));
 const testConfigurationGroupNames = {
-    [TestRunProfileBitset.Debug]: ( localize(12524, 'Debug')),
-    [TestRunProfileBitset.Run]: ( localize(12525, 'Run')),
-    [TestRunProfileBitset.Coverage]: ( localize(12526, 'Coverage')),
+    [TestRunProfileBitset.Debug]: ( localize(12664, 'Debug')),
+    [TestRunProfileBitset.Run]: ( localize(12665, 'Run')),
+    [TestRunProfileBitset.Coverage]: ( localize(12666, 'Coverage')),
 };
 var TestCommandId;
 (function (TestCommandId) {

package/vscode/src/vs/workbench/contrib/testing/common/getComputedState.d.ts

@@ -0,0 +1,21 @@
+import { TestResultState } from "./testTypes.js";
+/**
+ * Accessor for nodes in get and refresh computed state.
+ */
+export interface IComputedStateAccessor<T> {
+    getOwnState(item: T): TestResultState | undefined;
+    getCurrentComputedState(item: T): TestResultState;
+    setComputedState(item: T, state: TestResultState): void;
+    getChildren(item: T): Iterable<T>;
+    getParents(item: T): Iterable<T>;
+}
+export interface IComputedStateAndDurationAccessor<T> extends IComputedStateAccessor<T> {
+    getOwnDuration(item: T): number | undefined;
+    getCurrentComputedDuration(item: T): number | undefined;
+    setComputedDuration(item: T, duration: number | undefined): void;
+}
+/**
+ * Refreshes the computed state for the node and its parents. Any changes
+ * elements cause `addUpdated` to be called.
+ */
+export declare const refreshComputedState: <T extends object>(accessor: IComputedStateAccessor<T>, node: T, explicitNewComputedState?: TestResultState, refreshDuration?: boolean) => Set<T>;

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

@@ -0,0 +1,105 @@
+
+import { Iterable } from '../../../../base/common/iterator.js';
+import { TestResultState } from './testTypes.js';
+import { makeEmptyCounts, maxPriority, statePriority } from './testingStates.js';
+
+const isDurationAccessor = (accessor) => 'getOwnDuration' in accessor;
+const getComputedState = (accessor, node, force = false) => {
+    let computed = accessor.getCurrentComputedState(node);
+    if (computed === undefined || force) {
+        computed = accessor.getOwnState(node) ?? TestResultState.Unset;
+        let childrenCount = 0;
+        const stateMap = makeEmptyCounts();
+        for (const child of accessor.getChildren(node)) {
+            const childComputed = getComputedState(accessor, child);
+            childrenCount++;
+            stateMap[childComputed]++;
+            computed = childComputed === TestResultState.Skipped && computed === TestResultState.Unset
+                ? TestResultState.Skipped : maxPriority(computed, childComputed);
+        }
+        if (childrenCount > LARGE_NODE_THRESHOLD) {
+            largeNodeChildrenStates.set(node, stateMap);
+        }
+        accessor.setComputedState(node, computed);
+    }
+    return computed;
+};
+const getComputedDuration = (accessor, node, force = false) => {
+    let computed = accessor.getCurrentComputedDuration(node);
+    if (computed === undefined || force) {
+        const own = accessor.getOwnDuration(node);
+        if (own !== undefined) {
+            computed = own;
+        }
+        else {
+            computed = undefined;
+            for (const child of accessor.getChildren(node)) {
+                const d = getComputedDuration(accessor, child);
+                if (d !== undefined) {
+                    computed = (computed || 0) + d;
+                }
+            }
+        }
+        accessor.setComputedDuration(node, computed);
+    }
+    return computed;
+};
+const LARGE_NODE_THRESHOLD = 64;
+const largeNodeChildrenStates = ( new WeakMap());
+const refreshComputedState = (accessor, node, explicitNewComputedState, refreshDuration = true) => {
+    const oldState = accessor.getCurrentComputedState(node);
+    const oldPriority = statePriority[oldState];
+    const newState = explicitNewComputedState ?? getComputedState(accessor, node, true);
+    const newPriority = statePriority[newState];
+    const toUpdate = ( new Set());
+    if (newPriority !== oldPriority) {
+        accessor.setComputedState(node, newState);
+        toUpdate.add(node);
+        let moveFromState = oldState;
+        let moveToState = newState;
+        for (const parent of accessor.getParents(node)) {
+            const lnm = largeNodeChildrenStates.get(parent);
+            if (lnm) {
+                lnm[moveFromState]--;
+                lnm[moveToState]++;
+            }
+            const prev = accessor.getCurrentComputedState(parent);
+            if (newPriority > oldPriority) {
+                if (prev !== undefined && statePriority[prev] >= newPriority) {
+                    break;
+                }
+                if (lnm && lnm[moveToState] > 1) {
+                    break;
+                }
+                accessor.setComputedState(parent, newState);
+                toUpdate.add(parent);
+            }
+            else  {
+                if (prev === undefined || statePriority[prev] > oldPriority) {
+                    break;
+                }
+                if (lnm && lnm[moveFromState] > 0) {
+                    break;
+                }
+                moveToState = getComputedState(accessor, parent, true);
+                accessor.setComputedState(parent, moveToState);
+                toUpdate.add(parent);
+            }
+            moveFromState = prev;
+        }
+    }
+    if (isDurationAccessor(accessor) && refreshDuration) {
+        for (const parent of Iterable.concat(Iterable.single(node), accessor.getParents(node))) {
+            const oldDuration = accessor.getCurrentComputedDuration(parent);
+            const newDuration = getComputedDuration(accessor, parent, true);
+            if (oldDuration === newDuration) {
+                break;
+            }
+            accessor.setComputedDuration(parent, newDuration);
+            toUpdate.add(parent);
+        }
+    }
+    return toUpdate;
+};
+
+export { refreshComputedState };

package/vscode/src/vs/workbench/contrib/testing/common/testCoverage.d.ts

@@ -0,0 +1,98 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { ResourceMap } from "../../../../base/common/map.js";
+import { ITransaction } from "../../../../base/common/observable.js";
+import { IPrefixTreeNode, WellDefinedPrefixTree } from "../../../../base/common/prefixTree.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IUriIdentityService } from "../../../../platform/uriIdentity/common/uriIdentity.service.js";
+import { TestId } from "./testId.js";
+import { LiveTestResult } from "./testResult.js";
+import { CoverageDetails, ICoverageCount, IFileCoverage } from "./testTypes.js";
+export interface ICoverageAccessor {
+    getCoverageDetails: (id: string, testId: string | undefined, token: CancellationToken) => Promise<CoverageDetails[]>;
+}
+/**
+ * Class that exposese coverage information for a run.
+ */
+export declare class TestCoverage {
+    readonly result: LiveTestResult;
+    readonly fromTaskId: string;
+    private readonly uriIdentityService;
+    private readonly accessor;
+    private readonly fileCoverage;
+    readonly didAddCoverage: import("../../../../base/common/observable.js").IObservableSignal<IPrefixTreeNode<AbstractFileCoverage>[]>;
+    readonly tree: WellDefinedPrefixTree<AbstractFileCoverage>;
+    readonly associatedData: Map<unknown, unknown>;
+    constructor(result: LiveTestResult, fromTaskId: string, uriIdentityService: IUriIdentityService, accessor: ICoverageAccessor);
+    /** Gets all test IDs that were included in this test run. */
+    allPerTestIDs(): Generator<string, void, unknown>;
+    append(coverage: IFileCoverage, tx: ITransaction | undefined): void;
+    /**
+     * Builds a new tree filtered to per-test coverage data for the given ID.
+     */
+    filterTreeForTest(testId: TestId): WellDefinedPrefixTree<AbstractFileCoverage>;
+    /**
+     * Gets coverage information for all files.
+     */
+    getAllFiles(): ResourceMap<FileCoverage>;
+    /**
+     * Gets coverage information for a specific file.
+     */
+    getUri(uri: URI): FileCoverage | undefined;
+    /**
+     * Gets computed information for a file, including DFS-computed information
+     * from child tests.
+     */
+    getComputedForUri(uri: URI): AbstractFileCoverage | undefined;
+    private treePathForUri;
+    private treePathToUri;
+}
+export declare const getTotalCoveragePercent: (statement: ICoverageCount, branch: ICoverageCount | undefined, function_: ICoverageCount | undefined) => number;
+export declare abstract class AbstractFileCoverage {
+    readonly fromResult: LiveTestResult;
+    id: string;
+    readonly uri: URI;
+    statement: ICoverageCount;
+    branch?: ICoverageCount;
+    declaration?: ICoverageCount;
+    readonly didChange: import("../../../../base/common/observable.js").IObservableSignal<void>;
+    /**
+     * Gets the total coverage percent based on information provided.
+     * This is based on the Clover total coverage formula
+     */
+    get tpc(): number;
+    /**
+     * Per-test coverage data for this file, if available.
+     */
+    perTestData?: Set<string>;
+    constructor(coverage: IFileCoverage, fromResult: LiveTestResult);
+}
+/**
+ * File coverage info computed from children in the tree, not provided by the
+ * extension.
+ */
+export declare class ComputedFileCoverage extends AbstractFileCoverage {
+}
+/**
+ * A virtual node that doesn't have any added coverage info.
+ */
+export declare class BypassedFileCoverage extends ComputedFileCoverage {
+    constructor(uri: URI, result: LiveTestResult);
+}
+export declare class FileCoverage extends AbstractFileCoverage {
+    private readonly accessor;
+    private _details?;
+    private resolved?;
+    private _detailsForTest?;
+    /** Gets whether details are synchronously available */
+    get hasSynchronousDetails(): boolean | undefined;
+    constructor(coverage: IFileCoverage, fromResult: LiveTestResult, accessor: ICoverageAccessor);
+    /**
+     * Gets per-line coverage details.
+     */
+    detailsForTest(_testId: TestId, token?: Readonly<CancellationToken>): Promise<CoverageDetails[]>;
+    /**
+     * Gets per-line coverage details.
+     */
+    details(token?: Readonly<CancellationToken>): Promise<CoverageDetails[]>;
+}
+export declare const totalFromCoverageDetails: (uri: URI, details: CoverageDetails[]) => IFileCoverage;

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

@@ -0,0 +1,203 @@
+
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { deepClone } from '../../../../base/common/objects.js';
+import '../../../../base/common/observableInternal/index.js';
+import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
+import { URI } from '../../../../base/common/uri.js';
+import './testTypes.js';
+import { observableSignal } from '../../../../base/common/observableInternal/observables/observableSignal.js';
+
+let incId = 0;
+class TestCoverage {
+    constructor(result, fromTaskId, uriIdentityService, accessor) {
+        this.result = result;
+        this.fromTaskId = fromTaskId;
+        this.uriIdentityService = uriIdentityService;
+        this.accessor = accessor;
+        this.fileCoverage = ( new ResourceMap());
+        this.didAddCoverage = observableSignal(this);
+        this.tree = ( new WellDefinedPrefixTree());
+        this.associatedData = ( new Map());
+    }
+    *allPerTestIDs() {
+        const seen = ( new Set());
+        for (const root of this.tree.nodes) {
+            if (root.value && root.value.perTestData) {
+                for (const id of root.value.perTestData) {
+                    if (!( seen.has(id))) {
+                        seen.add(id);
+                        yield id;
+                    }
+                }
+            }
+        }
+    }
+    append(coverage, tx) {
+        const previous = this.getComputedForUri(coverage.uri);
+        const result = this.result;
+        const applyDelta = (kind, node) => {
+            if (!node[kind]) {
+                if (coverage[kind]) {
+                    node[kind] = { ...coverage[kind] };
+                }
+            }
+            else {
+                node[kind].covered += (coverage[kind]?.covered || 0) - (previous?.[kind]?.covered || 0);
+                node[kind].total += (coverage[kind]?.total || 0) - (previous?.[kind]?.total || 0);
+            }
+        };
+        const canonical = [...this.treePathForUri(coverage.uri,  true)];
+        const chain = [];
+        this.tree.mutatePath(this.treePathForUri(coverage.uri,  false), node => {
+            chain.push(node);
+            if (chain.length === canonical.length) {
+                if (node.value) {
+                    const v = node.value;
+                    v.id = coverage.id;
+                    v.statement = coverage.statement;
+                    v.branch = coverage.branch;
+                    v.declaration = coverage.declaration;
+                }
+                else {
+                    const v = node.value = ( new FileCoverage(coverage, result, this.accessor));
+                    this.fileCoverage.set(coverage.uri, v);
+                }
+            }
+            else {
+                if (!node.value) {
+                    const intermediate = deepClone(coverage);
+                    intermediate.id = String(incId++);
+                    intermediate.uri = this.treePathToUri(canonical.slice(0, chain.length));
+                    node.value = ( new ComputedFileCoverage(intermediate, result));
+                }
+                else {
+                    applyDelta('statement', node.value);
+                    applyDelta('branch', node.value);
+                    applyDelta('declaration', node.value);
+                    node.value.didChange.trigger(tx);
+                }
+            }
+            if (coverage.testIds) {
+                node.value.perTestData ??= ( new Set());
+                for (const id of coverage.testIds) {
+                    node.value.perTestData.add(id);
+                }
+            }
+        });
+        if (chain) {
+            this.didAddCoverage.trigger(tx, chain);
+        }
+    }
+    filterTreeForTest(testId) {
+        const tree = ( new WellDefinedPrefixTree());
+        for (const node of ( this.tree.values())) {
+            if (node instanceof FileCoverage) {
+                if (!node.perTestData?.has(( testId.toString()))) {
+                    continue;
+                }
+                const canonical = [...this.treePathForUri(node.uri,  true)];
+                const chain = [];
+                tree.mutatePath(this.treePathForUri(node.uri,  false), n => {
+                    chain.push(n);
+                    n.value ??= ( new BypassedFileCoverage(this.treePathToUri(canonical.slice(0, chain.length)), node.fromResult));
+                });
+            }
+        }
+        return tree;
+    }
+    getAllFiles() {
+        return this.fileCoverage;
+    }
+    getUri(uri) {
+        return this.fileCoverage.get(uri);
+    }
+    getComputedForUri(uri) {
+        return this.tree.find(this.treePathForUri(uri,  false));
+    }
+    *treePathForUri(uri, canconicalPath) {
+        yield uri.scheme;
+        yield uri.authority;
+        const path = !canconicalPath && this.uriIdentityService.extUri.ignorePathCasing(uri) ? uri.path.toLowerCase() : uri.path;
+        yield* path.split('/');
+    }
+    treePathToUri(path) {
+        return ( URI.from({ scheme: path[0], authority: path[1], path: path.slice(2).join('/') }));
+    }
+}
+const getTotalCoveragePercent = (statement, branch, function_) => {
+    let numerator = statement.covered;
+    let denominator = statement.total;
+    if (branch) {
+        numerator += branch.covered;
+        denominator += branch.total;
+    }
+    if (function_) {
+        numerator += function_.covered;
+        denominator += function_.total;
+    }
+    return denominator === 0 ? 1 : numerator / denominator;
+};
+class AbstractFileCoverage {
+    get tpc() {
+        return getTotalCoveragePercent(this.statement, this.branch, this.declaration);
+    }
+    constructor(coverage, fromResult) {
+        this.fromResult = fromResult;
+        this.didChange = observableSignal(this);
+        this.id = coverage.id;
+        this.uri = coverage.uri;
+        this.statement = coverage.statement;
+        this.branch = coverage.branch;
+        this.declaration = coverage.declaration;
+    }
+}
+class ComputedFileCoverage extends AbstractFileCoverage {
+}
+class BypassedFileCoverage extends ComputedFileCoverage {
+    constructor(uri, result) {
+        super({ id: String(incId++), uri, statement: { covered: 0, total: 0 } }, result);
+    }
+}
+class FileCoverage extends AbstractFileCoverage {
+    get hasSynchronousDetails() {
+        return this._details instanceof Array || this.resolved;
+    }
+    constructor(coverage, fromResult, accessor) {
+        super(coverage, fromResult);
+        this.accessor = accessor;
+    }
+    async detailsForTest(_testId, token = CancellationToken.None) {
+        this._detailsForTest ??= ( new Map());
+        const testId = ( _testId.toString());
+        const prev = this._detailsForTest.get(testId);
+        if (prev) {
+            return prev;
+        }
+        const promise = (async () => {
+            try {
+                return await this.accessor.getCoverageDetails(this.id, testId, token);
+            }
+            catch (e) {
+                this._detailsForTest?.delete(testId);
+                throw e;
+            }
+        })();
+        this._detailsForTest.set(testId, promise);
+        return promise;
+    }
+    async details(token = CancellationToken.None) {
+        this._details ??= this.accessor.getCoverageDetails(this.id, undefined, token);
+        try {
+            const d = await this._details;
+            this.resolved = true;
+            return d;
+        }
+        catch (e) {
+            this._details = undefined;
+            throw e;
+        }
+    }
+}
+
+export { AbstractFileCoverage, BypassedFileCoverage, ComputedFileCoverage, FileCoverage, TestCoverage, getTotalCoveragePercent };

package/vscode/src/vs/workbench/contrib/testing/common/testCoverageService.service.d.ts

@@ -1,7 +1,7 @@
 import { IObservable, ISettableObservable } from "../../../../base/common/observable.js";
-import { TestCoverage } from "@codingame/monaco-vscode-6845754f-e617-5ed9-8aaa-6ca3653a9532-common/vscode/vs/workbench/contrib/testing/common/testCoverage";
+import { TestCoverage } from "./testCoverage.js";
 import { TestId } from "./testId.js";
-import { ITestRunTaskResults } from "@codingame/monaco-vscode-6845754f-e617-5ed9-8aaa-6ca3653a9532-common/vscode/vs/workbench/contrib/testing/common/testResult";
+import { ITestRunTaskResults } from "./testResult.js";
 export declare const ITestCoverageService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITestCoverageService>;
 export interface ITestCoverageService {
     readonly _serviceBrand: undefined;