@codingame/monaco-vscode-api 9.0.3 → 10.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollOverlay.js

@@ -0,0 +1,372 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { addStandardDisposableListener, $, addDisposableListener, getWindow } from '../../../../../base/browser/dom.js';
+import { throttle, memoize } from '../../../../../base/common/decorators.js';
+import { Event } from '../../../../../base/common/event.js';
+import { Disposable, MutableDisposable, combinedDisposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { removeAnsiEscapeCodes } from '../../../../../base/common/strings.js';
+import './media/stickyScroll.css.js';
+import { localize } from '../../../../../nls.js';
+import { MenuId } from '../../../../../platform/actions/common/actions.js';
+import { IMenuService } from '../../../../../platform/actions/common/actions.service.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.service.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.service.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
+import { ITerminalConfigurationService } from '../../../terminal/browser/terminal.service.js';
+import { openContextMenu } from '../../../terminal/browser/terminalContextMenu.js';
+import { TERMINAL_CONFIG_SECTION } from '../../../terminal/common/terminal.js';
+import { terminalStrings } from '../../../terminal/common/terminalStrings.js';
+import { terminalStickyScrollHoverBackground, terminalStickyScrollBackground } from './terminalStickyScrollColorRegistry.js';
+let TerminalStickyScrollOverlay = class TerminalStickyScrollOverlay extends Disposable {
+    constructor(_instance, _xterm, _xtermColorProvider, _commandDetection, xtermCtor, configurationService, contextKeyService, _contextMenuService, _keybindingService, menuService, _terminalConfigurationService, _themeService) {
+        super();
+        this._instance = _instance;
+        this._xterm = _xterm;
+        this._xtermColorProvider = _xtermColorProvider;
+        this._commandDetection = _commandDetection;
+        this._contextMenuService = _contextMenuService;
+        this._keybindingService = _keybindingService;
+        this._terminalConfigurationService = _terminalConfigurationService;
+        this._themeService = _themeService;
+        this._refreshListeners = this._register(( (new MutableDisposable())));
+        this._state = 0 ;
+        this._isRefreshQueued = false;
+        this._rawMaxLineCount = 5;
+        this._contextMenu = this._register(menuService.createMenu(MenuId.TerminalStickyScrollContext, contextKeyService));
+        this._register(Event.runAndSubscribe(this._xterm.raw.buffer.onBufferChange, buffer => {
+            this._setState((buffer ?? this._xterm.raw.buffer.active).type === 'normal' ? 1  : 0 );
+        }));
+        this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
+            if (!e || e.affectsConfiguration("terminal.integrated.stickyScroll.maxLineCount" )) {
+                this._rawMaxLineCount = configurationService.getValue("terminal.integrated.stickyScroll.maxLineCount" );
+            }
+        }));
+        this._register(this._instance.onDidChangeTarget(() => this._syncOptions()));
+        xtermCtor.then(ctor => {
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._stickyScrollOverlay = this._register(( (new ctor({
+                rows: 1,
+                cols: this._xterm.raw.cols,
+                allowProposedApi: true,
+                ...this._getOptions()
+            }))));
+            this._refreshGpuAcceleration();
+            this._register(configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration(TERMINAL_CONFIG_SECTION)) {
+                    this._syncOptions();
+                }
+            }));
+            this._register(this._themeService.onDidColorThemeChange(() => {
+                this._syncOptions();
+            }));
+            this._register(this._xterm.raw.onResize(() => {
+                this._syncOptions();
+                this._refresh();
+            }));
+            this._register(this._instance.onDidChangeVisibility(isVisible => {
+                if (isVisible) {
+                    this._refresh();
+                }
+            }));
+            this._getSerializeAddonConstructor().then(SerializeAddon => {
+                if (this._store.isDisposed) {
+                    return;
+                }
+                this._serializeAddon = this._register(( (new SerializeAddon())));
+                this._xterm.raw.loadAddon(this._serializeAddon);
+                this._refresh();
+            });
+        });
+    }
+    lockHide() {
+        this._element?.classList.add('lock-hide');
+    }
+    unlockHide() {
+        this._element?.classList.remove('lock-hide');
+    }
+    _setState(state) {
+        if (this._state === state) {
+            return;
+        }
+        switch (state) {
+            case 0 : {
+                this._setVisible(false);
+                this._uninstallRefreshListeners();
+                break;
+            }
+            case 1 : {
+                this._refresh();
+                this._installRefreshListeners();
+                break;
+            }
+        }
+    }
+    _installRefreshListeners() {
+        if (!this._refreshListeners.value) {
+            this._refreshListeners.value = combinedDisposable(Event.any(this._xterm.raw.onScroll, this._xterm.raw.onLineFeed,
+            this._xterm.raw.onCursorMove)(() => this._refresh()), addStandardDisposableListener(this._xterm.raw.element.querySelector('.xterm-viewport'), 'scroll', () => this._refresh()));
+        }
+    }
+    _uninstallRefreshListeners() {
+        this._refreshListeners.clear();
+    }
+    _setVisible(isVisible) {
+        if (isVisible) {
+            this._ensureElement();
+        }
+        this._element?.classList.toggle("visible" , isVisible);
+    }
+    _refresh() {
+        if (this._isRefreshQueued) {
+            return;
+        }
+        this._isRefreshQueued = true;
+        queueMicrotask(() => {
+            this._refreshNow();
+            this._isRefreshQueued = false;
+        });
+    }
+    _refreshNow() {
+        const command = this._commandDetection.getCommandForLine(this._xterm.raw.buffer.active.viewportY);
+        this._currentStickyCommand = undefined;
+        if (!command) {
+            this._setVisible(false);
+            return;
+        }
+        if (!('marker' in command)) {
+            const partialCommand = this._commandDetection.currentCommand;
+            if (partialCommand?.commandStartMarker && partialCommand.commandExecutedMarker) {
+                this._updateContent(partialCommand, partialCommand.commandStartMarker);
+                return;
+            }
+            this._setVisible(false);
+            return;
+        }
+        const marker = command.marker;
+        if (!marker || marker.line === -1) {
+            this._setVisible(false);
+            return;
+        }
+        this._updateContent(command, marker);
+    }
+    _updateContent(command, startMarker) {
+        const xterm = this._xterm.raw;
+        if (!xterm.element?.parentElement || !this._stickyScrollOverlay || !this._serializeAddon) {
+            return;
+        }
+        if (command.promptStartMarker?.line === -1) {
+            this._setVisible(false);
+            return;
+        }
+        const buffer = xterm.buffer.active;
+        const promptRowCount = command.getPromptRowCount();
+        const commandRowCount = command.getCommandRowCount();
+        const stickyScrollLineStart = startMarker.line - (promptRowCount - 1);
+        const isPartialCommand = !('getOutput' in command);
+        const rowOffset = !isPartialCommand && command.endMarker ? Math.max(buffer.viewportY - command.endMarker.line + 1, 0) : 0;
+        const maxLineCount = Math.min(this._rawMaxLineCount, Math.floor(xterm.rows * 0.4 ));
+        const stickyScrollLineCount = Math.min(promptRowCount + commandRowCount - 1, maxLineCount) - rowOffset;
+        if (buffer.viewportY <= stickyScrollLineStart) {
+            this._setVisible(false);
+            return;
+        }
+        if (isPartialCommand && buffer.viewportY === buffer.baseY && buffer.cursorY === xterm.rows - 1) {
+            const line = buffer.getLine(buffer.baseY + xterm.rows - 1);
+            if ((buffer.cursorX === 1 && lineStartsWith(line, ':')) ||
+                (buffer.cursorX === 5 && lineStartsWith(line, '(END)'))) {
+                this._setVisible(false);
+                return;
+            }
+        }
+        const content = this._serializeAddon.serialize({
+            range: {
+                start: stickyScrollLineStart + rowOffset,
+                end: stickyScrollLineStart + rowOffset + Math.max(stickyScrollLineCount - 1, 0)
+            }
+        });
+        if (isPartialCommand && removeAnsiEscapeCodes(content).length === 0) {
+            this._setVisible(false);
+            return;
+        }
+        if (content && this._currentContent !== content ||
+            this._stickyScrollOverlay.cols !== xterm.cols ||
+            this._stickyScrollOverlay.rows !== stickyScrollLineCount) {
+            this._stickyScrollOverlay.resize(this._stickyScrollOverlay.cols, stickyScrollLineCount);
+            this._stickyScrollOverlay.write('\x1b[0m\x1b[H\x1b[2J');
+            this._stickyScrollOverlay.write(content);
+            this._currentContent = content;
+        }
+        if (content) {
+            this._currentStickyCommand = command;
+            this._setVisible(true);
+            if (this._element) {
+                const termBox = xterm.element.getBoundingClientRect();
+                if (termBox.height > 0) {
+                    const rowHeight = termBox.height / xterm.rows;
+                    const overlayHeight = stickyScrollLineCount * rowHeight;
+                    let endMarkerOffset = 0;
+                    if (!isPartialCommand && command.endMarker && command.endMarker.line !== -1) {
+                        if (buffer.viewportY + stickyScrollLineCount > command.endMarker.line) {
+                            const diff = buffer.viewportY + stickyScrollLineCount - command.endMarker.line;
+                            endMarkerOffset = diff * rowHeight;
+                        }
+                    }
+                    this._element.style.bottom = `${termBox.height - overlayHeight + 1 + endMarkerOffset}px`;
+                }
+            }
+        }
+        else {
+            this._setVisible(false);
+        }
+    }
+    _ensureElement() {
+        if (
+        this._element ||
+            !this._stickyScrollOverlay ||
+            !this._xterm?.raw.element?.parentElement) {
+            return;
+        }
+        const overlay = this._stickyScrollOverlay;
+        const hoverOverlay = $('.hover-overlay');
+        this._element = $('.terminal-sticky-scroll', undefined, hoverOverlay);
+        this._xterm.raw.element.parentElement.append(this._element);
+        this._register(toDisposable(() => this._element?.remove()));
+        let hoverTitle = ( localize(11689, 'Navigate to Command'));
+        const scrollToPreviousCommandKeybinding = this._keybindingService.lookupKeybinding("workbench.action.terminal.scrollToPreviousCommand" );
+        if (scrollToPreviousCommandKeybinding) {
+            const label = scrollToPreviousCommandKeybinding.getLabel();
+            if (label) {
+                hoverTitle += '\n' + ( localize(11690, "{0} ({1})", terminalStrings.scrollToPreviousCommand.value, label));
+            }
+        }
+        const scrollToNextCommandKeybinding = this._keybindingService.lookupKeybinding("workbench.action.terminal.scrollToNextCommand" );
+        if (scrollToNextCommandKeybinding) {
+            const label = scrollToNextCommandKeybinding.getLabel();
+            if (label) {
+                hoverTitle += '\n' + ( localize(11690, "{0} ({1})", terminalStrings.scrollToNextCommand.value, label));
+            }
+        }
+        hoverOverlay.title = hoverTitle;
+        const scrollBarWidth = this._xterm.raw._core.viewport?.scrollBarWidth;
+        if (scrollBarWidth !== undefined) {
+            this._element.style.right = `${scrollBarWidth}px`;
+        }
+        this._stickyScrollOverlay.open(this._element);
+        this._register(addStandardDisposableListener(hoverOverlay, 'click', () => {
+            if (this._xterm && this._currentStickyCommand) {
+                this._xterm.markTracker.revealCommand(this._currentStickyCommand);
+                this._instance.focus();
+            }
+        }));
+        this._register(addStandardDisposableListener(hoverOverlay, 'wheel', e => this._xterm?.raw.element?.dispatchEvent(( (new WheelEvent(e.type, e))))));
+        this._register(addDisposableListener(hoverOverlay, 'mousedown', e => {
+            e.stopImmediatePropagation();
+            e.preventDefault();
+        }));
+        this._register(addDisposableListener(hoverOverlay, 'contextmenu', e => {
+            e.stopImmediatePropagation();
+            e.preventDefault();
+            openContextMenu(getWindow(hoverOverlay), e, this._instance, this._contextMenu, this._contextMenuService);
+        }));
+        this._register(addStandardDisposableListener(hoverOverlay, 'mouseover', () => overlay.options.theme = this._getTheme(true)));
+        this._register(addStandardDisposableListener(hoverOverlay, 'mouseleave', () => overlay.options.theme = this._getTheme(false)));
+    }
+    _syncOptions() {
+        if (!this._stickyScrollOverlay) {
+            return;
+        }
+        this._stickyScrollOverlay.resize(this._xterm.raw.cols, this._stickyScrollOverlay.rows);
+        this._stickyScrollOverlay.options = this._getOptions();
+        this._refreshGpuAcceleration();
+    }
+    _getOptions() {
+        const o = this._xterm.raw.options;
+        return {
+            cursorInactiveStyle: 'none',
+            scrollback: 0,
+            logLevel: 'off',
+            theme: this._getTheme(false),
+            documentOverride: o.documentOverride,
+            fontFamily: o.fontFamily,
+            fontWeight: o.fontWeight,
+            fontWeightBold: o.fontWeightBold,
+            fontSize: o.fontSize,
+            letterSpacing: o.letterSpacing,
+            lineHeight: o.lineHeight,
+            drawBoldTextInBrightColors: o.drawBoldTextInBrightColors,
+            minimumContrastRatio: o.minimumContrastRatio,
+            tabStopWidth: o.tabStopWidth,
+            customGlyphs: o.customGlyphs,
+        };
+    }
+    async _refreshGpuAcceleration() {
+        if (this._shouldLoadWebgl() && !this._webglAddon) {
+            const WebglAddon = await this._getWebglAddonConstructor();
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._webglAddon = this._register(( (new WebglAddon())));
+            this._stickyScrollOverlay?.loadAddon(this._webglAddon);
+        }
+        else if (!this._shouldLoadWebgl() && this._webglAddon) {
+            this._webglAddon.dispose();
+            this._webglAddon = undefined;
+        }
+    }
+    _shouldLoadWebgl() {
+        return this._terminalConfigurationService.config.gpuAcceleration === 'auto' || this._terminalConfigurationService.config.gpuAcceleration === 'on';
+    }
+    _getTheme(isHovering) {
+        const theme = this._themeService.getColorTheme();
+        return {
+            ...this._xterm.getXtermTheme(),
+            background: isHovering
+                ? theme.getColor(terminalStickyScrollHoverBackground)?.toString() ?? this._xtermColorProvider.getBackgroundColor(theme)?.toString()
+                : theme.getColor(terminalStickyScrollBackground)?.toString() ?? this._xtermColorProvider.getBackgroundColor(theme)?.toString(),
+            selectionBackground: undefined,
+            selectionInactiveBackground: undefined
+        };
+    }
+    async _getSerializeAddonConstructor() {
+        return (await import('@xterm/addon-serialize').then(module => module.default ?? module)).SerializeAddon;
+    }
+    async _getWebglAddonConstructor() {
+        return (await import('@xterm/addon-webgl').then(module => module.default ?? module)).WebglAddon;
+    }
+};
+TerminalStickyScrollOverlay.__decorator = ( (__decorate([
+    throttle(0)
+], TerminalStickyScrollOverlay.prototype, "_syncOptions", null)));
+TerminalStickyScrollOverlay.__decorator = ( (__decorate([
+    throttle(0)
+], TerminalStickyScrollOverlay.prototype, "_refreshGpuAcceleration", null)));
+TerminalStickyScrollOverlay.__decorator = ( (__decorate([
+    memoize
+], TerminalStickyScrollOverlay.prototype, "_getSerializeAddonConstructor", null)));
+TerminalStickyScrollOverlay.__decorator = ( (__decorate([
+    memoize
+], TerminalStickyScrollOverlay.prototype, "_getWebglAddonConstructor", null)));
+TerminalStickyScrollOverlay = ( (__decorate([
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IContextKeyService))),
+    ( (__param(7, IContextMenuService))),
+    ( (__param(8, IKeybindingService))),
+    ( (__param(9, IMenuService))),
+    ( (__param(10, ITerminalConfigurationService))),
+    ( (__param(11, IThemeService)))
+], TerminalStickyScrollOverlay)));
+function lineStartsWith(line, text) {
+    if (!line) {
+        return false;
+    }
+    for (let i = 0; i < text.length; i++) {
+        if (line.getCell(i)?.getChars() !== text[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+export { TerminalStickyScrollOverlay };

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

@@ -1,22 +1,11 @@
-var TerminalSuggestCommandId;
-( (function(TerminalSuggestCommandId) {
-    TerminalSuggestCommandId["SelectPrevSuggestion"] = "workbench.action.terminal.selectPrevSuggestion";
-    TerminalSuggestCommandId["SelectPrevPageSuggestion"] = "workbench.action.terminal.selectPrevPageSuggestion";
-    TerminalSuggestCommandId["SelectNextSuggestion"] = "workbench.action.terminal.selectNextSuggestion";
-    TerminalSuggestCommandId["SelectNextPageSuggestion"] = "workbench.action.terminal.selectNextPageSuggestion";
-    TerminalSuggestCommandId["AcceptSelectedSuggestion"] = "workbench.action.terminal.acceptSelectedSuggestion";
-    TerminalSuggestCommandId["AcceptSelectedSuggestionEnter"] = "workbench.action.terminal.acceptSelectedSuggestionEnter";
-    TerminalSuggestCommandId["HideSuggestWidget"] = "workbench.action.terminal.hideSuggestWidget";
-    TerminalSuggestCommandId["ClearSuggestCache"] = "workbench.action.terminal.clearSuggestCache";
-})(TerminalSuggestCommandId || (TerminalSuggestCommandId = {})));
 const defaultTerminalSuggestCommandsToSkipShell = [
-    TerminalSuggestCommandId.SelectPrevSuggestion,
-    TerminalSuggestCommandId.SelectPrevPageSuggestion,
-    TerminalSuggestCommandId.SelectNextSuggestion,
-    TerminalSuggestCommandId.SelectNextPageSuggestion,
-    TerminalSuggestCommandId.AcceptSelectedSuggestion,
-    TerminalSuggestCommandId.AcceptSelectedSuggestionEnter,
-    TerminalSuggestCommandId.HideSuggestWidget,
-    TerminalSuggestCommandId.ClearSuggestCache,
+    "workbench.action.terminal.selectPrevSuggestion" ,
+    "workbench.action.terminal.selectPrevPageSuggestion" ,
+    "workbench.action.terminal.selectNextSuggestion" ,
+    "workbench.action.terminal.selectNextPageSuggestion" ,
+    "workbench.action.terminal.acceptSelectedSuggestion" ,
+    "workbench.action.terminal.acceptSelectedSuggestionEnter" ,
+    "workbench.action.terminal.hideSuggestWidget" ,
+    "workbench.action.terminal.clearSuggestCache" ,
 ];
-export { TerminalSuggestCommandId, defaultTerminalSuggestCommandsToSkipShell };
+export { defaultTerminalSuggestCommandsToSkipShell };

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

@@ -1,19 +1,18 @@
 import { Iterable } from '../../../../base/common/iterator.js';
-import { TestResultState } from './testTypes.js';
 import { statePriority, maxPriority, makeEmptyCounts } 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;
+        computed = accessor.getOwnState(node) ?? 0 ;
         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);
+            computed = childComputed === 5  && computed === 0
+                ? 5  : maxPriority(computed, childComputed);
         }
         if (childrenCount > LARGE_NODE_THRESHOLD) {
             largeNodeChildrenStates.set(node, stateMap);

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

@@ -1,6 +1,6 @@
 import { ITransaction } from '../../../../base/common/observableInternal/base.js';
-import { IObservableSignal } from '../../../../base/common/observableInternal/utils.js';
 import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { IObservableSignal } from '../../../../base/common/observableInternal/utils.js';
 import { ResourceMap } from '../../../../base/common/map.js';
 import { IPrefixTreeNode, WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
 import { URI } from '../../../../base/common/uri.js';

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

@@ -2,8 +2,10 @@ import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { ResourceMap } from '../../../../base/common/map.js';
 import { deepClone } from '../../../../base/common/objects.js';
 import '../../../../base/common/arrays.js';
-import '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/event.js';
+import '../../../../base/common/lifecycle.js';
 import '../../../../base/common/observableInternal/autorun.js';
+import '../../../../base/common/observableInternal/derived.js';
 import { observableSignal } from '../../../../base/common/observableInternal/utils.js';
 import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
 import { URI } from '../../../../base/common/uri.js';

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

@@ -1,14 +1,3 @@
-var TestIdPathParts;
-( (function(TestIdPathParts) {
-    TestIdPathParts["Delimiter"] = "\0";
-})(TestIdPathParts || (TestIdPathParts = {})));
-var TestPosition;
-( (function(TestPosition) {
-    TestPosition[TestPosition["IsSame"] = 0] = "IsSame";
-    TestPosition[TestPosition["Disconnected"] = 1] = "Disconnected";
-    TestPosition[TestPosition["IsChild"] = 2] = "IsChild";
-    TestPosition[TestPosition["IsParent"] = 3] = "IsParent";
-})(TestPosition || (TestPosition = {})));
 class TestId {
     static fromExtHostTestItem(item, rootId, parent = item.parent) {
         if (item._isRoot) {
@@ -22,43 +11,43 @@ class TestId {
         return ( new TestId(path.reverse()));
     }
     static isRoot(idString) {
-        return !idString.includes(TestIdPathParts.Delimiter);
+        return !idString.includes("\0" );
     }
     static root(idString) {
-        const idx = idString.indexOf(TestIdPathParts.Delimiter);
+        const idx = idString.indexOf("\0" );
         return idx === -1 ? idString : idString.slice(0, idx);
     }
     static fromString(idString) {
-        return ( new TestId(idString.split(TestIdPathParts.Delimiter)));
+        return ( new TestId(idString.split("\0" )));
     }
     static join(base, b) {
         return ( new TestId([...base.path, b]));
     }
     static joinToString(base, b) {
-        return ( base.toString()) + TestIdPathParts.Delimiter + b;
+        return ( base.toString()) + "\0"  + b;
     }
     static parentId(idString) {
-        const idx = idString.lastIndexOf(TestIdPathParts.Delimiter);
+        const idx = idString.lastIndexOf("\0" );
         return idx === -1 ? undefined : idString.slice(0, idx);
     }
     static localId(idString) {
-        const idx = idString.lastIndexOf(TestIdPathParts.Delimiter);
-        return idx === -1 ? idString : idString.slice(idx + TestIdPathParts.Delimiter.length);
+        const idx = idString.lastIndexOf("\0" );
+        return idx === -1 ? idString : idString.slice(idx + "\0" .length);
     }
     static isChild(maybeParent, maybeChild) {
-        return maybeChild[maybeParent.length] === TestIdPathParts.Delimiter && maybeChild.startsWith(maybeParent);
+        return maybeChild[maybeParent.length] === "\0"  && maybeChild.startsWith(maybeParent);
     }
     static compare(a, b) {
         if (a === b) {
-            return TestPosition.IsSame;
+            return 0 ;
         }
         if (TestId.isChild(a, b)) {
-            return TestPosition.IsChild;
+            return 2 ;
         }
         if (TestId.isChild(b, a)) {
-            return TestPosition.IsParent;
+            return 3 ;
         }
-        return TestPosition.Disconnected;
+        return 1 ;
     }
     static getLengthOfCommonPrefix(length, getId) {
         if (length === 0) {
@@ -115,16 +104,16 @@ class TestId {
         }
         for (let i = 0; i < other.viewEnd && i < this.viewEnd; i++) {
             if (other.path[i] !== this.path[i]) {
-                return TestPosition.Disconnected;
+                return 1 ;
             }
         }
         if (other.viewEnd > this.viewEnd) {
-            return TestPosition.IsChild;
+            return 2 ;
         }
         if (other.viewEnd < this.viewEnd) {
-            return TestPosition.IsParent;
+            return 3 ;
         }
-        return TestPosition.IsSame;
+        return 0 ;
     }
     toJSON() {
         return ( this.toString());
@@ -133,11 +122,11 @@ class TestId {
         if (!this.stringifed) {
             this.stringifed = this.path[0];
             for (let i = 1; i < this.viewEnd; i++) {
-                this.stringifed += TestIdPathParts.Delimiter;
+                this.stringifed += "\0" ;
                 this.stringifed += this.path[i];
             }
         }
         return this.stringifed;
     }
 }
-export { TestId, TestIdPathParts, TestPosition };
+export { TestId };