@codingame/monaco-vscode-debug-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/debug/browser/exceptionWidget.js

@@ -0,0 +1,131 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/exceptionWidget.css.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { append, isAncestorOfActiveElement, $ as $$1 } from 'vscode/vscode/vs/base/browser/dom';
+import { ZoneWidget } from 'vscode/vscode/vs/editor/contrib/zoneWidget/browser/zoneWidget';
+import { EDITOR_CONTRIBUTION_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { registerColor } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { LinkDetector } from './linkDetector.js';
+import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { widgetClose } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
+
+const $ = $$1;
+const debugExceptionWidgetBorder = registerColor('debugExceptionWidget.border', { dark: '#a31515', light: '#a31515', hcDark: '#a31515', hcLight: '#a31515' }, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/exceptionWidget',
+    'debugExceptionWidgetBorder',
+    'Exception widget border color.'
+)));
+const debugExceptionWidgetBackground = registerColor('debugExceptionWidget.background', { dark: '#420b0d', light: '#f1dfde', hcDark: '#420b0d', hcLight: '#f1dfde' }, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/exceptionWidget',
+    'debugExceptionWidgetBackground',
+    'Exception widget background color.'
+)));
+let ExceptionWidget = class ExceptionWidget extends ZoneWidget {
+    constructor(editor, exceptionInfo, debugSession, themeService, instantiationService) {
+        super(editor, { showFrame: true, showArrow: true, isAccessible: true, frameWidth: 1, className: 'exception-widget-container' });
+        this.exceptionInfo = exceptionInfo;
+        this.debugSession = debugSession;
+        this.instantiationService = instantiationService;
+        this.applyTheme(themeService.getColorTheme());
+        this._disposables.add(themeService.onDidColorThemeChange(this.applyTheme.bind(this)));
+        this.create();
+        const onDidLayoutChangeScheduler = ( new RunOnceScheduler(() => this._doLayout(undefined, undefined), 50));
+        this._disposables.add(this.editor.onDidLayoutChange(() => onDidLayoutChangeScheduler.schedule()));
+        this._disposables.add(onDidLayoutChangeScheduler);
+    }
+    applyTheme(theme) {
+        this.backgroundColor = theme.getColor(debugExceptionWidgetBackground);
+        const frameColor = theme.getColor(debugExceptionWidgetBorder);
+        this.style({
+            arrowColor: frameColor,
+            frameColor: frameColor
+        });
+    }
+    _applyStyles() {
+        if (this.container) {
+            this.container.style.backgroundColor = this.backgroundColor ? ( this.backgroundColor.toString()) : '';
+        }
+        super._applyStyles();
+    }
+    _fillContainer(container) {
+        this.setCssClass('exception-widget');
+        const fontInfo = this.editor.getOption(50 );
+        container.style.fontSize = `${fontInfo.fontSize}px`;
+        container.style.lineHeight = `${fontInfo.lineHeight}px`;
+        container.tabIndex = 0;
+        const title = $('.title');
+        const label = $('.label');
+        append(title, label);
+        const actions = $('.actions');
+        append(title, actions);
+        label.textContent = this.exceptionInfo.id ? ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/exceptionWidget',
+            'exceptionThrownWithId',
+            'Exception has occurred: {0}',
+            this.exceptionInfo.id
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/exceptionWidget',
+            'exceptionThrown',
+            'Exception has occurred.'
+        ));
+        let ariaLabel = label.textContent;
+        const actionBar = ( new ActionBar(actions));
+        actionBar.push(( new Action('editor.closeExceptionWidget', ( localizeWithPath('vs/workbench/contrib/debug/browser/exceptionWidget', 'close', "Close")), ThemeIcon.asClassName(widgetClose), true, async () => {
+            const contribution = this.editor.getContribution(EDITOR_CONTRIBUTION_ID);
+            contribution?.closeExceptionWidget();
+        })), { label: false, icon: true });
+        append(container, title);
+        if (this.exceptionInfo.description) {
+            const description = $('.description');
+            description.textContent = this.exceptionInfo.description;
+            ariaLabel += ', ' + this.exceptionInfo.description;
+            append(container, description);
+        }
+        if (this.exceptionInfo.details && this.exceptionInfo.details.stackTrace) {
+            const stackTrace = $('.stack-trace');
+            const linkDetector = this.instantiationService.createInstance(LinkDetector);
+            const linkedStackTrace = linkDetector.linkify(this.exceptionInfo.details.stackTrace, true, this.debugSession ? this.debugSession.root : undefined);
+            stackTrace.appendChild(linkedStackTrace);
+            append(container, stackTrace);
+            ariaLabel += ', ' + this.exceptionInfo.details.stackTrace;
+        }
+        container.setAttribute('aria-label', ariaLabel);
+    }
+    _doLayout(_heightInPixel, _widthInPixel) {
+        this.container.style.height = 'initial';
+        const lineHeight = this.editor.getOption(67 );
+        const arrowHeight = Math.round(lineHeight / 3);
+        const computedLinesNumber = Math.ceil((this.container.offsetHeight + arrowHeight) / lineHeight);
+        this._relayout(computedLinesNumber);
+    }
+    focus() {
+        this.container?.focus();
+    }
+    hasFocus() {
+        if (!this.container) {
+            return false;
+        }
+        return isAncestorOfActiveElement(this.container);
+    }
+};
+ExceptionWidget = ( __decorate([
+    ( __param(3, IThemeService)),
+    ( __param(4, IInstantiationService))
+], ExceptionWidget));
+
+export { ExceptionWidget };

package/vscode/src/vs/workbench/contrib/debug/browser/extensionHostDebugService.js

@@ -0,0 +1,142 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ExtensionHostDebugChannelClient, ExtensionHostDebugBroadcastChannel } from '../../../../platform/debug/common/extensionHostDebugIpc.js';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { isFolderToOpen, isWorkspaceToOpen } from 'vscode/vscode/vs/platform/window/common/window';
+import { toWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier, hasWorkspaceFileExtension, IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+
+var BrowserExtensionHostDebugService_1;
+let BrowserExtensionHostDebugService = class BrowserExtensionHostDebugService extends ExtensionHostDebugChannelClient {
+    static { BrowserExtensionHostDebugService_1 = this; }
+    static { this.LAST_EXTENSION_DEVELOPMENT_WORKSPACE_KEY = 'debug.lastExtensionDevelopmentWorkspace'; }
+    constructor(remoteAgentService, environmentService, logService, hostService, contextService, storageService, fileService) {
+        const connection = remoteAgentService.getConnection();
+        let channel;
+        if (connection) {
+            channel = connection.getChannel(ExtensionHostDebugBroadcastChannel.ChannelName);
+        }
+        else {
+            channel = { call: async () => undefined, listen: () => Event.None };
+        }
+        super(channel);
+        this.storageService = storageService;
+        this.fileService = fileService;
+        if (environmentService.options && environmentService.options.workspaceProvider) {
+            this.workspaceProvider = environmentService.options.workspaceProvider;
+        }
+        else {
+            this.workspaceProvider = { open: async () => true, workspace: undefined, trusted: undefined };
+            logService.warn('Extension Host Debugging not available due to missing workspace provider.');
+        }
+        this._register(this.onReload(event => {
+            if (environmentService.isExtensionDevelopment && environmentService.debugExtensionHost.debugId === event.sessionId) {
+                hostService.reload();
+            }
+        }));
+        this._register(this.onClose(event => {
+            if (environmentService.isExtensionDevelopment && environmentService.debugExtensionHost.debugId === event.sessionId) {
+                hostService.close();
+            }
+        }));
+        if (environmentService.isExtensionDevelopment && !environmentService.extensionTestsLocationURI) {
+            const workspaceId = toWorkspaceIdentifier(contextService.getWorkspace());
+            if (isSingleFolderWorkspaceIdentifier(workspaceId) || isWorkspaceIdentifier(workspaceId)) {
+                const serializedWorkspace = isSingleFolderWorkspaceIdentifier(workspaceId) ? { folderUri: workspaceId.uri.toJSON() } : { workspaceUri: workspaceId.configPath.toJSON() };
+                storageService.store(BrowserExtensionHostDebugService_1.LAST_EXTENSION_DEVELOPMENT_WORKSPACE_KEY, JSON.stringify(serializedWorkspace), 0 , 1 );
+            }
+            else {
+                storageService.remove(BrowserExtensionHostDebugService_1.LAST_EXTENSION_DEVELOPMENT_WORKSPACE_KEY, 0 );
+            }
+        }
+    }
+    async openExtensionDevelopmentHostWindow(args, _debugRenderer) {
+        const environment = ( new Map());
+        const fileUriArg = this.findArgument('file-uri', args);
+        if (fileUriArg && !hasWorkspaceFileExtension(fileUriArg)) {
+            environment.set('openFile', fileUriArg);
+        }
+        const copyArgs = [
+            'extensionDevelopmentPath',
+            'extensionTestsPath',
+            'extensionEnvironment',
+            'debugId',
+            'inspect-brk-extensions',
+            'inspect-extensions',
+        ];
+        for (const argName of copyArgs) {
+            const value = this.findArgument(argName, args);
+            if (value) {
+                environment.set(argName, value);
+            }
+        }
+        let debugWorkspace = undefined;
+        const folderUriArg = this.findArgument('folder-uri', args);
+        if (folderUriArg) {
+            debugWorkspace = { folderUri: ( URI.parse(folderUriArg)) };
+        }
+        else {
+            const fileUriArg = this.findArgument('file-uri', args);
+            if (fileUriArg && hasWorkspaceFileExtension(fileUriArg)) {
+                debugWorkspace = { workspaceUri: ( URI.parse(fileUriArg)) };
+            }
+        }
+        const extensionTestsPath = this.findArgument('extensionTestsPath', args);
+        if (!debugWorkspace && !extensionTestsPath) {
+            const lastExtensionDevelopmentWorkspace = this.storageService.get(BrowserExtensionHostDebugService_1.LAST_EXTENSION_DEVELOPMENT_WORKSPACE_KEY, 0 );
+            if (lastExtensionDevelopmentWorkspace) {
+                try {
+                    const serializedWorkspace = JSON.parse(lastExtensionDevelopmentWorkspace);
+                    if (serializedWorkspace.workspaceUri) {
+                        debugWorkspace = { workspaceUri: URI.revive(serializedWorkspace.workspaceUri) };
+                    }
+                    else if (serializedWorkspace.folderUri) {
+                        debugWorkspace = { folderUri: URI.revive(serializedWorkspace.folderUri) };
+                    }
+                }
+                catch (error) {
+                }
+            }
+        }
+        if (debugWorkspace) {
+            const debugWorkspaceResource = isFolderToOpen(debugWorkspace) ? debugWorkspace.folderUri : isWorkspaceToOpen(debugWorkspace) ? debugWorkspace.workspaceUri : undefined;
+            if (debugWorkspaceResource) {
+                const workspaceExists = await this.fileService.exists(debugWorkspaceResource);
+                if (!workspaceExists) {
+                    debugWorkspace = undefined;
+                }
+            }
+        }
+        const success = await this.workspaceProvider.open(debugWorkspace, {
+            reuse: false,
+            payload: Array.from(environment.entries())
+        });
+        return { success };
+    }
+    findArgument(key, args) {
+        for (const a of args) {
+            const k = `--${key}=`;
+            if (a.indexOf(k) === 0) {
+                return a.substring(k.length);
+            }
+        }
+        return undefined;
+    }
+};
+BrowserExtensionHostDebugService = BrowserExtensionHostDebugService_1 = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, IBrowserWorkbenchEnvironmentService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IHostService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IFileService))
+], BrowserExtensionHostDebugService));
+
+export { BrowserExtensionHostDebugService };

package/vscode/src/vs/workbench/contrib/debug/browser/linkDetector.js

@@ -0,0 +1,262 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { normalize, posix, join } from 'vscode/vscode/vs/base/common/path';
+import { isWindows, isMacintosh } from 'vscode/vscode/vs/base/common/platform';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { StandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { getWindow } from 'vscode/vscode/vs/base/browser/dom';
+
+const CONTROL_CODES = '\\u0000-\\u0020\\u007f-\\u009f';
+const WEB_LINK_REGEX = ( new RegExp(
+    '(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s' + CONTROL_CODES + '"]{2,}[^\\s' + CONTROL_CODES + '"\')}\\],:;.!?]',
+    'ug'
+));
+const WIN_ABSOLUTE_PATH = /(?:[a-zA-Z]:(?:(?:\\|\/)[\w\.-]*)+)/;
+const WIN_RELATIVE_PATH = /(?:(?:\~|\.)(?:(?:\\|\/)[\w\.-]*)+)/;
+const WIN_PATH = ( new RegExp(`(${WIN_ABSOLUTE_PATH.source}|${WIN_RELATIVE_PATH.source})`));
+const POSIX_PATH = /((?:\~|\.)?(?:\/[\w\.-]*)+)/;
+const LINE_COLUMN = /(?:\:([\d]+))?(?:\:([\d]+))?/;
+const PATH_LINK_REGEX = ( new RegExp(
+    `${isWindows ? WIN_PATH.source : POSIX_PATH.source}${LINE_COLUMN.source}`,
+    'g'
+));
+const LINE_COLUMN_REGEX = /:([\d]+)(?::([\d]+))?$/;
+const MAX_LENGTH = 2000;
+let LinkDetector = class LinkDetector {
+    constructor(editorService, fileService, openerService, pathService, tunnelService, environmentService, configurationService) {
+        this.editorService = editorService;
+        this.fileService = fileService;
+        this.openerService = openerService;
+        this.pathService = pathService;
+        this.tunnelService = tunnelService;
+        this.environmentService = environmentService;
+        this.configurationService = configurationService;
+    }
+    linkify(text, splitLines, workspaceFolder, includeFulltext) {
+        if (splitLines) {
+            const lines = text.split('\n');
+            for (let i = 0; i < lines.length - 1; i++) {
+                lines[i] = lines[i] + '\n';
+            }
+            if (!lines[lines.length - 1]) {
+                lines.pop();
+            }
+            const elements = ( lines.map(line => this.linkify(line, false, workspaceFolder, includeFulltext)));
+            if (elements.length === 1) {
+                return elements[0];
+            }
+            const container = document.createElement('span');
+            elements.forEach(e => container.appendChild(e));
+            return container;
+        }
+        const container = document.createElement('span');
+        for (const part of this.detectLinks(text)) {
+            try {
+                switch (part.kind) {
+                    case 'text':
+                        container.appendChild(document.createTextNode(part.value));
+                        break;
+                    case 'web':
+                        container.appendChild(this.createWebLink(includeFulltext ? text : undefined, part.value));
+                        break;
+                    case 'path': {
+                        const path = part.captures[0];
+                        const lineNumber = part.captures[1] ? Number(part.captures[1]) : 0;
+                        const columnNumber = part.captures[2] ? Number(part.captures[2]) : 0;
+                        container.appendChild(this.createPathLink(includeFulltext ? text : undefined, part.value, path, lineNumber, columnNumber, workspaceFolder));
+                        break;
+                    }
+                }
+            }
+            catch (e) {
+                container.appendChild(document.createTextNode(part.value));
+            }
+        }
+        return container;
+    }
+    createWebLink(fulltext, url) {
+        const link = this.createLink(url);
+        let uri = ( URI.parse(url));
+        const lineCol = LINE_COLUMN_REGEX.exec(uri.path);
+        if (lineCol) {
+            uri = uri.with({
+                path: uri.path.slice(0, lineCol.index),
+                fragment: `L${lineCol[0].slice(1)}`
+            });
+        }
+        this.decorateLink(link, uri, fulltext, async () => {
+            if (uri.scheme === Schemas.file) {
+                const fsPath = uri.fsPath;
+                const path = await this.pathService.path;
+                const fileUrl = normalize(((path.sep === posix.sep) && isWindows) ? fsPath.replace(/\\/g, posix.sep) : fsPath);
+                const fileUri = ( URI.parse(fileUrl));
+                const exists = await this.fileService.exists(fileUri);
+                if (!exists) {
+                    return;
+                }
+                await this.editorService.openEditor({
+                    resource: fileUri,
+                    options: {
+                        pinned: true,
+                        selection: lineCol ? { startLineNumber: +lineCol[1], startColumn: +lineCol[2] } : undefined,
+                    },
+                });
+                return;
+            }
+            this.openerService.open(url, { allowTunneling: (!!this.environmentService.remoteAuthority && this.configurationService.getValue('remote.forwardOnOpen')) });
+        });
+        return link;
+    }
+    createPathLink(fulltext, text, path, lineNumber, columnNumber, workspaceFolder) {
+        if (path[0] === '/' && path[1] === '/') {
+            return document.createTextNode(text);
+        }
+        const options = { selection: { startLineNumber: lineNumber, startColumn: columnNumber } };
+        if (path[0] === '.') {
+            if (!workspaceFolder) {
+                return document.createTextNode(text);
+            }
+            const uri = workspaceFolder.toResource(path);
+            const link = this.createLink(text);
+            this.decorateLink(link, uri, fulltext, (preserveFocus) => this.editorService.openEditor({ resource: uri, options: { ...options, preserveFocus } }));
+            return link;
+        }
+        if (path[0] === '~') {
+            const userHome = this.pathService.resolvedUserHome;
+            if (userHome) {
+                path = join(userHome.fsPath, path.substring(1));
+            }
+        }
+        const link = this.createLink(text);
+        link.tabIndex = 0;
+        const uri = URI.file(normalize(path));
+        this.fileService.stat(uri).then(stat => {
+            if (stat.isDirectory) {
+                return;
+            }
+            this.decorateLink(link, uri, fulltext, (preserveFocus) => this.editorService.openEditor({ resource: uri, options: { ...options, preserveFocus } }));
+        }).catch(() => {
+        });
+        return link;
+    }
+    createLink(text) {
+        const link = document.createElement('a');
+        link.textContent = text;
+        return link;
+    }
+    decorateLink(link, uri, fulltext, onClick) {
+        link.classList.add('link');
+        const followLink = this.tunnelService.canTunnel(uri) ? ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/linkDetector',
+            'followForwardedLink',
+            "follow link using forwarded port"
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/linkDetector',
+            'followLink',
+            "follow link"
+        ));
+        link.title = fulltext
+            ? (isMacintosh ? ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/linkDetector',
+            'fileLinkWithPathMac',
+            "Cmd + click to {0}\n{1}",
+            followLink,
+            fulltext
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/linkDetector',
+            'fileLinkWithPath',
+            "Ctrl + click to {0}\n{1}",
+            followLink,
+            fulltext
+        )))
+            : (isMacintosh ? ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/linkDetector',
+            'fileLinkMac',
+            "Cmd + click to {0}",
+            followLink
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/linkDetector',
+            'fileLink',
+            "Ctrl + click to {0}",
+            followLink
+        )));
+        link.onmousemove = (event) => { link.classList.toggle('pointer', isMacintosh ? event.metaKey : event.ctrlKey); };
+        link.onmouseleave = () => link.classList.remove('pointer');
+        link.onclick = (event) => {
+            const selection = getWindow(link).getSelection();
+            if (!selection || selection.type === 'Range') {
+                return;
+            }
+            if (!(isMacintosh ? event.metaKey : event.ctrlKey)) {
+                return;
+            }
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            onClick(false);
+        };
+        link.onkeydown = e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.keyCode === 3  || event.keyCode === 10 ) {
+                event.preventDefault();
+                event.stopPropagation();
+                onClick(event.keyCode === 10 );
+            }
+        };
+    }
+    detectLinks(text) {
+        if (text.length > MAX_LENGTH) {
+            return [{ kind: 'text', value: text, captures: [] }];
+        }
+        const regexes = [WEB_LINK_REGEX, PATH_LINK_REGEX];
+        const kinds = ['web', 'path'];
+        const result = [];
+        const splitOne = (text, regexIndex) => {
+            if (regexIndex >= regexes.length) {
+                result.push({ value: text, kind: 'text', captures: [] });
+                return;
+            }
+            const regex = regexes[regexIndex];
+            let currentIndex = 0;
+            let match;
+            regex.lastIndex = 0;
+            while ((match = regex.exec(text)) !== null) {
+                const stringBeforeMatch = text.substring(currentIndex, match.index);
+                if (stringBeforeMatch) {
+                    splitOne(stringBeforeMatch, regexIndex + 1);
+                }
+                const value = match[0];
+                result.push({
+                    value: value,
+                    kind: kinds[regexIndex],
+                    captures: match.slice(1)
+                });
+                currentIndex = match.index + value.length;
+            }
+            const stringAfterMatches = text.substring(currentIndex);
+            if (stringAfterMatches) {
+                splitOne(stringAfterMatches, regexIndex + 1);
+            }
+        };
+        splitOne(text, 0);
+        return result;
+    }
+};
+LinkDetector = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IOpenerService)),
+    ( __param(3, IPathService)),
+    ( __param(4, ITunnelService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IConfigurationService))
+], LinkDetector));
+
+export { LinkDetector };