@codingame/monaco-vscode-xterm-addons-common 24.1.0

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/markNavigationAddon.js

@@ -0,0 +1,582 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Disposable, MutableDisposable, dispose, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry';
+import { getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { isFullTerminalCommand } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/commandDetection/terminalCommand';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { TerminalContribSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/terminalContribExports';
+
+var Boundary;
+(function (Boundary) {
+    Boundary[Boundary["Top"] = 0] = "Top";
+    Boundary[Boundary["Bottom"] = 1] = "Bottom";
+})(Boundary || (Boundary = {}));
+var ScrollPosition;
+(function (ScrollPosition) {
+    ScrollPosition[ScrollPosition["Top"] = 0] = "Top";
+    ScrollPosition[ScrollPosition["Middle"] = 1] = "Middle";
+})(ScrollPosition || (ScrollPosition = {}));
+let MarkNavigationAddon = class MarkNavigationAddon extends Disposable {
+    activate(terminal) {
+        this._terminal = terminal;
+        this._register(this._terminal.onData(() => {
+            this._currentMarker = Boundary.Bottom;
+        }));
+    }
+    constructor(_capabilities, _configurationService, _themeService) {
+        super();
+        this._capabilities = _capabilities;
+        this._configurationService = _configurationService;
+        this._themeService = _themeService;
+        this._currentMarker = Boundary.Bottom;
+        this._selectionStart = null;
+        this._isDisposable = false;
+        this._commandGuideDecorations = this._register(( new MutableDisposable()));
+    }
+    _getMarkers(skipEmptyCommands) {
+        const commandCapability = this._capabilities.get(TerminalCapability.CommandDetection);
+        const partialCommandCapability = this._capabilities.get(TerminalCapability.PartialCommandDetection);
+        const markCapability = this._capabilities.get(TerminalCapability.BufferMarkDetection);
+        let markers = [];
+        if (commandCapability) {
+            markers = coalesce(( commandCapability.commands.filter(e => skipEmptyCommands ? e.exitCode !== undefined : true).map(e => e.promptStartMarker ?? e.marker)));
+            if (commandCapability.currentCommand?.promptStartMarker && commandCapability.currentCommand.commandExecutedMarker) {
+                markers.push(commandCapability.currentCommand?.promptStartMarker);
+            }
+        }
+        else if (partialCommandCapability) {
+            markers.push(...partialCommandCapability.commands);
+        }
+        if (markCapability && !skipEmptyCommands) {
+            let next = markCapability.markers().next()?.value;
+            const arr = [];
+            while (next) {
+                arr.push(next);
+                next = markCapability.markers().next()?.value;
+            }
+            markers = arr;
+        }
+        return markers;
+    }
+    _findCommand(marker) {
+        const commandCapability = this._capabilities.get(TerminalCapability.CommandDetection);
+        if (commandCapability) {
+            const command = commandCapability.commands.find(e => e.marker?.line === marker.line || e.promptStartMarker?.line === marker.line);
+            if (command) {
+                return command;
+            }
+            if (commandCapability.currentCommand) {
+                return commandCapability.currentCommand;
+            }
+        }
+        return undefined;
+    }
+    clear() {
+        this._currentMarker = Boundary.Bottom;
+        this._resetNavigationDecorations();
+        this._selectionStart = null;
+    }
+    _resetNavigationDecorations() {
+        if (this._navigationDecorations) {
+            dispose(this._navigationDecorations);
+        }
+        this._navigationDecorations = [];
+    }
+    _isEmptyCommand(marker) {
+        if (marker === Boundary.Bottom) {
+            return true;
+        }
+        if (marker === Boundary.Top) {
+            return !( this._getMarkers(true).map(e => e.line)).includes(0);
+        }
+        return !this._getMarkers(true).includes(marker);
+    }
+    scrollToPreviousMark(scrollPosition = ScrollPosition.Middle, retainSelection = false, skipEmptyCommands = true) {
+        if (!this._terminal) {
+            return;
+        }
+        if (!retainSelection) {
+            this._selectionStart = null;
+        }
+        let markerIndex;
+        const currentLineY = typeof this._currentMarker === 'object'
+            ? this.getTargetScrollLine(this._currentMarker.line, scrollPosition)
+            : Math.min(getLine(this._terminal, this._currentMarker), this._terminal.buffer.active.baseY);
+        const viewportY = this._terminal.buffer.active.viewportY;
+        if (typeof this._currentMarker === 'object' ? !this._isMarkerInViewport(this._terminal, this._currentMarker) : currentLineY !== viewportY) {
+            const markersBelowViewport = this._getMarkers(skipEmptyCommands).filter(e => e.line >= viewportY).length;
+            markerIndex = this._getMarkers(skipEmptyCommands).length - markersBelowViewport - 1;
+        }
+        else if (this._currentMarker === Boundary.Bottom) {
+            markerIndex = this._getMarkers(skipEmptyCommands).length - 1;
+        }
+        else if (this._currentMarker === Boundary.Top) {
+            markerIndex = -1;
+        }
+        else if (this._isDisposable) {
+            markerIndex = this._findPreviousMarker(skipEmptyCommands);
+            this._currentMarker.dispose();
+            this._isDisposable = false;
+        }
+        else {
+            if (skipEmptyCommands && this._isEmptyCommand(this._currentMarker)) {
+                markerIndex = this._findPreviousMarker(true);
+            }
+            else {
+                markerIndex = this._getMarkers(skipEmptyCommands).indexOf(this._currentMarker) - 1;
+            }
+        }
+        if (markerIndex < 0) {
+            this._currentMarker = Boundary.Top;
+            this._terminal.scrollToTop();
+            this._resetNavigationDecorations();
+            return;
+        }
+        this._currentMarker = this._getMarkers(skipEmptyCommands)[markerIndex];
+        this._scrollToCommand(this._currentMarker, scrollPosition);
+    }
+    scrollToNextMark(scrollPosition = ScrollPosition.Middle, retainSelection = false, skipEmptyCommands = true) {
+        if (!this._terminal) {
+            return;
+        }
+        if (!retainSelection) {
+            this._selectionStart = null;
+        }
+        let markerIndex;
+        const currentLineY = typeof this._currentMarker === 'object'
+            ? this.getTargetScrollLine(this._currentMarker.line, scrollPosition)
+            : Math.min(getLine(this._terminal, this._currentMarker), this._terminal.buffer.active.baseY);
+        const viewportY = this._terminal.buffer.active.viewportY;
+        if (typeof this._currentMarker === 'object' ? !this._isMarkerInViewport(this._terminal, this._currentMarker) : currentLineY !== viewportY) {
+            const markersAboveViewport = this._getMarkers(skipEmptyCommands).filter(e => e.line <= viewportY).length;
+            markerIndex = markersAboveViewport;
+        }
+        else if (this._currentMarker === Boundary.Bottom) {
+            markerIndex = this._getMarkers(skipEmptyCommands).length;
+        }
+        else if (this._currentMarker === Boundary.Top) {
+            markerIndex = 0;
+        }
+        else if (this._isDisposable) {
+            markerIndex = this._findNextMarker(skipEmptyCommands);
+            this._currentMarker.dispose();
+            this._isDisposable = false;
+        }
+        else {
+            if (skipEmptyCommands && this._isEmptyCommand(this._currentMarker)) {
+                markerIndex = this._findNextMarker(true);
+            }
+            else {
+                markerIndex = this._getMarkers(skipEmptyCommands).indexOf(this._currentMarker) + 1;
+            }
+        }
+        if (markerIndex >= this._getMarkers(skipEmptyCommands).length) {
+            this._currentMarker = Boundary.Bottom;
+            this._terminal.scrollToBottom();
+            this._resetNavigationDecorations();
+            return;
+        }
+        this._currentMarker = this._getMarkers(skipEmptyCommands)[markerIndex];
+        this._scrollToCommand(this._currentMarker, scrollPosition);
+    }
+    _scrollToCommand(marker, position) {
+        const command = this._findCommand(marker);
+        if (command) {
+            this.revealCommand(command, position);
+        }
+        else {
+            this._scrollToMarker(marker, position);
+        }
+    }
+    _scrollToMarker(start, position, end, options) {
+        if (!this._terminal) {
+            return;
+        }
+        if (!this._isMarkerInViewport(this._terminal, start) || options?.forceScroll) {
+            const line = this.getTargetScrollLine(toLineIndex(start), position);
+            this._terminal.scrollToLine(line);
+        }
+        if (!options?.hideDecoration) {
+            if (options?.bufferRange) {
+                this._highlightBufferRange(options.bufferRange);
+            }
+            else {
+                this.registerTemporaryDecoration(start, end, true);
+            }
+        }
+    }
+    _createMarkerForOffset(marker, offset) {
+        if (offset === 0 && isMarker(marker)) {
+            return marker;
+        }
+        else {
+            const offsetMarker = this._terminal?.registerMarker(-this._terminal.buffer.active.cursorY + toLineIndex(marker) - this._terminal.buffer.active.baseY + offset);
+            if (offsetMarker) {
+                return offsetMarker;
+            }
+            else {
+                throw ( new Error(`Could not register marker with offset ${toLineIndex(marker)}, ${offset}`));
+            }
+        }
+    }
+    revealCommand(command, position = ScrollPosition.Middle) {
+        const marker = isFullTerminalCommand(command) ? command.marker : command.commandStartMarker;
+        if (!this._terminal || !marker) {
+            return;
+        }
+        const line = toLineIndex(marker);
+        const promptRowCount = command.getPromptRowCount();
+        const commandRowCount = command.getCommandRowCount();
+        this._scrollToMarker(line - (promptRowCount - 1), position, line + (commandRowCount - 1));
+    }
+    revealRange(range) {
+        this._scrollToMarker(range.start.y - 1, ScrollPosition.Middle, range.end.y - 1, {
+            bufferRange: range,
+            forceScroll: !!this._configurationService.getValue(TerminalContribSettingId.StickyScrollEnabled)
+        });
+    }
+    showCommandGuide(command) {
+        if (!this._terminal) {
+            return;
+        }
+        if (!command) {
+            this._commandGuideDecorations.clear();
+            this._activeCommandGuide = undefined;
+            return;
+        }
+        if (this._activeCommandGuide === command) {
+            return;
+        }
+        if (command.marker) {
+            this._activeCommandGuide = command;
+            const store = this._commandGuideDecorations.value = ( new DisposableStore());
+            if (!command.executedMarker || !command.endMarker) {
+                return;
+            }
+            const startLine = command.marker.line - (command.getPromptRowCount() - 1);
+            const decorationCount = toLineIndex(command.endMarker) - startLine;
+            if (decorationCount > 200) {
+                return;
+            }
+            for (let i = 0; i < decorationCount; i++) {
+                const decoration = this._terminal.registerDecoration({
+                    marker: this._createMarkerForOffset(startLine, i)
+                });
+                if (decoration) {
+                    store.add(decoration);
+                    let renderedElement;
+                    store.add(decoration.onRender(element => {
+                        if (!renderedElement) {
+                            renderedElement = element;
+                            element.classList.add('terminal-command-guide');
+                            if (i === 0) {
+                                element.classList.add('top');
+                            }
+                            if (i === decorationCount - 1) {
+                                element.classList.add('bottom');
+                            }
+                        }
+                        if (this._terminal?.element) {
+                            element.style.marginLeft = `-${getWindow(this._terminal.element).getComputedStyle(this._terminal.element).paddingLeft}`;
+                        }
+                    }));
+                }
+            }
+        }
+    }
+    saveScrollState() {
+        this._scrollState = { viewportY: this._terminal?.buffer.active.viewportY ?? 0 };
+    }
+    restoreScrollState() {
+        if (this._scrollState && this._terminal) {
+            this._terminal.scrollToLine(this._scrollState.viewportY);
+            this._scrollState = undefined;
+        }
+    }
+    _highlightBufferRange(range) {
+        if (!this._terminal) {
+            return;
+        }
+        this._resetNavigationDecorations();
+        const startLine = range.start.y;
+        const decorationCount = range.end.y - range.start.y + 1;
+        for (let i = 0; i < decorationCount; i++) {
+            const decoration = this._terminal.registerDecoration({
+                marker: this._createMarkerForOffset(startLine - 1, i),
+                x: range.start.x - 1,
+                width: (range.end.x - 1) - (range.start.x - 1) + 1,
+                overviewRulerOptions: undefined
+            });
+            if (decoration) {
+                this._navigationDecorations?.push(decoration);
+                let renderedElement;
+                decoration.onRender(element => {
+                    if (!renderedElement) {
+                        renderedElement = element;
+                        element.classList.add('terminal-range-highlight');
+                    }
+                });
+                decoration.onDispose(() => { this._navigationDecorations = this._navigationDecorations?.filter(d => d !== decoration); });
+            }
+        }
+    }
+    registerTemporaryDecoration(marker, endMarker, showOutline) {
+        if (!this._terminal) {
+            return;
+        }
+        this._resetNavigationDecorations();
+        const color = this._themeService.getColorTheme().getColor(TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR);
+        const startLine = toLineIndex(marker);
+        const decorationCount = endMarker ? toLineIndex(endMarker) - startLine + 1 : 1;
+        for (let i = 0; i < decorationCount; i++) {
+            const decoration = this._terminal.registerDecoration({
+                marker: this._createMarkerForOffset(marker, i),
+                width: this._terminal.cols,
+                overviewRulerOptions: i === 0 ? {
+                    color: color?.toString() || '#a0a0a0cc'
+                } : undefined
+            });
+            if (decoration) {
+                this._navigationDecorations?.push(decoration);
+                let renderedElement;
+                decoration.onRender(element => {
+                    if (!renderedElement) {
+                        renderedElement = element;
+                        element.classList.add('terminal-scroll-highlight');
+                        if (showOutline) {
+                            element.classList.add('terminal-scroll-highlight-outline');
+                        }
+                        if (i === 0) {
+                            element.classList.add('top');
+                        }
+                        if (i === decorationCount - 1) {
+                            element.classList.add('bottom');
+                        }
+                    }
+                    else {
+                        element.classList.add('terminal-scroll-highlight');
+                    }
+                    if (this._terminal?.element) {
+                        element.style.marginLeft = `-${getWindow(this._terminal.element).getComputedStyle(this._terminal.element).paddingLeft}`;
+                    }
+                });
+                decoration.onDispose(() => { this._navigationDecorations = this._navigationDecorations?.filter(d => d !== decoration); });
+                if (showOutline) {
+                    timeout(350).then(() => {
+                        if (renderedElement) {
+                            renderedElement.classList.remove('terminal-scroll-highlight-outline');
+                        }
+                    });
+                }
+            }
+        }
+    }
+    scrollToLine(line, position) {
+        this._terminal?.scrollToLine(this.getTargetScrollLine(line, position));
+    }
+    getTargetScrollLine(line, position) {
+        if (this._terminal && position === ScrollPosition.Middle) {
+            return Math.max(line - Math.floor(this._terminal.rows / 4), 0);
+        }
+        return line;
+    }
+    _isMarkerInViewport(terminal, marker) {
+        const viewportY = terminal.buffer.active.viewportY;
+        const line = toLineIndex(marker);
+        return line >= viewportY && line < viewportY + terminal.rows;
+    }
+    scrollToClosestMarker(startMarkerId, endMarkerId, highlight) {
+        const detectionCapability = this._capabilities.get(TerminalCapability.BufferMarkDetection);
+        if (!detectionCapability) {
+            return;
+        }
+        const startMarker = detectionCapability.getMark(startMarkerId);
+        if (!startMarker) {
+            return;
+        }
+        const endMarker = endMarkerId ? detectionCapability.getMark(endMarkerId) : startMarker;
+        this._scrollToMarker(startMarker, ScrollPosition.Top, endMarker, { hideDecoration: !highlight });
+    }
+    selectToPreviousMark() {
+        if (!this._terminal) {
+            return;
+        }
+        if (this._selectionStart === null) {
+            this._selectionStart = this._currentMarker;
+        }
+        if (( this._capabilities.has(TerminalCapability.CommandDetection))) {
+            this.scrollToPreviousMark(ScrollPosition.Middle, true, true);
+        }
+        else {
+            this.scrollToPreviousMark(ScrollPosition.Middle, true, false);
+        }
+        selectLines(this._terminal, this._currentMarker, this._selectionStart);
+    }
+    selectToNextMark() {
+        if (!this._terminal) {
+            return;
+        }
+        if (this._selectionStart === null) {
+            this._selectionStart = this._currentMarker;
+        }
+        if (( this._capabilities.has(TerminalCapability.CommandDetection))) {
+            this.scrollToNextMark(ScrollPosition.Middle, true, true);
+        }
+        else {
+            this.scrollToNextMark(ScrollPosition.Middle, true, false);
+        }
+        selectLines(this._terminal, this._currentMarker, this._selectionStart);
+    }
+    selectToPreviousLine() {
+        if (!this._terminal) {
+            return;
+        }
+        if (this._selectionStart === null) {
+            this._selectionStart = this._currentMarker;
+        }
+        this.scrollToPreviousLine(this._terminal, ScrollPosition.Middle, true);
+        selectLines(this._terminal, this._currentMarker, this._selectionStart);
+    }
+    selectToNextLine() {
+        if (!this._terminal) {
+            return;
+        }
+        if (this._selectionStart === null) {
+            this._selectionStart = this._currentMarker;
+        }
+        this.scrollToNextLine(this._terminal, ScrollPosition.Middle, true);
+        selectLines(this._terminal, this._currentMarker, this._selectionStart);
+    }
+    scrollToPreviousLine(xterm, scrollPosition = ScrollPosition.Middle, retainSelection = false) {
+        if (!retainSelection) {
+            this._selectionStart = null;
+        }
+        if (this._currentMarker === Boundary.Top) {
+            xterm.scrollToTop();
+            return;
+        }
+        if (this._currentMarker === Boundary.Bottom) {
+            this._currentMarker = this._registerMarkerOrThrow(xterm, this._getOffset(xterm) - 1);
+        }
+        else {
+            const offset = this._getOffset(xterm);
+            if (this._isDisposable) {
+                this._currentMarker.dispose();
+            }
+            this._currentMarker = this._registerMarkerOrThrow(xterm, offset - 1);
+        }
+        this._isDisposable = true;
+        this._scrollToMarker(this._currentMarker, scrollPosition);
+    }
+    scrollToNextLine(xterm, scrollPosition = ScrollPosition.Middle, retainSelection = false) {
+        if (!retainSelection) {
+            this._selectionStart = null;
+        }
+        if (this._currentMarker === Boundary.Bottom) {
+            xterm.scrollToBottom();
+            return;
+        }
+        if (this._currentMarker === Boundary.Top) {
+            this._currentMarker = this._registerMarkerOrThrow(xterm, this._getOffset(xterm) + 1);
+        }
+        else {
+            const offset = this._getOffset(xterm);
+            if (this._isDisposable) {
+                this._currentMarker.dispose();
+            }
+            this._currentMarker = this._registerMarkerOrThrow(xterm, offset + 1);
+        }
+        this._isDisposable = true;
+        this._scrollToMarker(this._currentMarker, scrollPosition);
+    }
+    _registerMarkerOrThrow(xterm, cursorYOffset) {
+        const marker = xterm.registerMarker(cursorYOffset);
+        if (!marker) {
+            throw ( new Error(`Could not create marker for ${cursorYOffset}`));
+        }
+        return marker;
+    }
+    _getOffset(xterm) {
+        if (this._currentMarker === Boundary.Bottom) {
+            return 0;
+        }
+        else if (this._currentMarker === Boundary.Top) {
+            return 0 - (xterm.buffer.active.baseY + xterm.buffer.active.cursorY);
+        }
+        else {
+            let offset = getLine(xterm, this._currentMarker);
+            offset -= xterm.buffer.active.baseY + xterm.buffer.active.cursorY;
+            return offset;
+        }
+    }
+    _findPreviousMarker(skipEmptyCommands = false) {
+        if (this._currentMarker === Boundary.Top) {
+            return 0;
+        }
+        else if (this._currentMarker === Boundary.Bottom) {
+            return this._getMarkers(skipEmptyCommands).length - 1;
+        }
+        let i;
+        for (i = this._getMarkers(skipEmptyCommands).length - 1; i >= 0; i--) {
+            if (this._getMarkers(skipEmptyCommands)[i].line < this._currentMarker.line) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    _findNextMarker(skipEmptyCommands = false) {
+        if (this._currentMarker === Boundary.Top) {
+            return 0;
+        }
+        else if (this._currentMarker === Boundary.Bottom) {
+            return this._getMarkers(skipEmptyCommands).length - 1;
+        }
+        let i;
+        for (i = 0; i < this._getMarkers(skipEmptyCommands).length; i++) {
+            if (this._getMarkers(skipEmptyCommands)[i].line > this._currentMarker.line) {
+                return i;
+            }
+        }
+        return this._getMarkers(skipEmptyCommands).length;
+    }
+};
+MarkNavigationAddon = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IThemeService))
+], MarkNavigationAddon));
+function getLine(xterm, marker) {
+    if (marker === Boundary.Bottom) {
+        return xterm.buffer.active.baseY + xterm.rows - 1;
+    }
+    if (marker === Boundary.Top) {
+        return 0;
+    }
+    return marker.line;
+}
+function selectLines(xterm, start, end) {
+    if (end === null) {
+        end = Boundary.Bottom;
+    }
+    let startLine = getLine(xterm, start);
+    let endLine = getLine(xterm, end);
+    if (startLine > endLine) {
+        const temp = startLine;
+        startLine = endLine;
+        endLine = temp;
+    }
+    endLine -= 1;
+    xterm.selectLines(startLine, endLine);
+}
+function isMarker(value) {
+    return typeof value !== 'number';
+}
+function toLineIndex(line) {
+    return isMarker(line) ? line.line : line;
+}
+
+export { MarkNavigationAddon, ScrollPosition, getLine, selectLines };

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermAddonImporter.d.ts

@@ -0,0 +1,25 @@
+import type { ClipboardAddon as ClipboardAddonType } from "@xterm/addon-clipboard";
+import type { ImageAddon as ImageAddonType } from "@xterm/addon-image";
+import type { LigaturesAddon as LigaturesAddonType } from "@xterm/addon-ligatures";
+import type { ProgressAddon as ProgressAddonType } from "@xterm/addon-progress";
+import type { SearchAddon as SearchAddonType } from "@xterm/addon-search";
+import type { SerializeAddon as SerializeAddonType } from "@xterm/addon-serialize";
+import type { Unicode11Addon as Unicode11AddonType } from "@xterm/addon-unicode11";
+import type { WebglAddon as WebglAddonType } from "@xterm/addon-webgl";
+export interface IXtermAddonNameToCtor {
+    clipboard: typeof ClipboardAddonType;
+    image: typeof ImageAddonType;
+    ligatures: typeof LigaturesAddonType;
+    progress: typeof ProgressAddonType;
+    search: typeof SearchAddonType;
+    serialize: typeof SerializeAddonType;
+    unicode11: typeof Unicode11AddonType;
+    webgl: typeof WebglAddonType;
+}
+/**
+ * Exposes a simple interface to consumers, encapsulating the messy import xterm
+ * addon import and caching logic.
+ */
+export declare class XtermAddonImporter {
+    importAddon<T extends keyof IXtermAddonNameToCtor>(name: T): Promise<IXtermAddonNameToCtor[T]>;
+}

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermAddonImporter.js

@@ -0,0 +1,43 @@
+
+
+const importedAddons = ( new Map());
+class XtermAddonImporter {
+    async importAddon(name) {
+        let addon = importedAddons.get(name);
+        if (!addon) {
+            switch (name) {
+                case 'clipboard':
+                    addon = (await import('@xterm/addon-clipboard').then(module => module.default ?? module)).ClipboardAddon;
+                    break;
+                case 'image':
+                    addon = (await import('@xterm/addon-image').then(module => module.default ?? module)).ImageAddon;
+                    break;
+                case 'ligatures':
+                    addon = (await import('@xterm/addon-ligatures').then(module => module.default ?? module)).LigaturesAddon;
+                    break;
+                case 'progress':
+                    addon = (await import('@xterm/addon-progress').then(module => module.default ?? module)).ProgressAddon;
+                    break;
+                case 'search':
+                    addon = (await import('@xterm/addon-search').then(module => module.default ?? module)).SearchAddon;
+                    break;
+                case 'serialize':
+                    addon = (await import('@xterm/addon-serialize').then(module => module.default ?? module)).SerializeAddon;
+                    break;
+                case 'unicode11':
+                    addon = (await import('@xterm/addon-unicode11').then(module => module.default ?? module)).Unicode11Addon;
+                    break;
+                case 'webgl':
+                    addon = (await import('@xterm/addon-webgl').then(module => module.default ?? module)).WebglAddon;
+                    break;
+            }
+            if (!addon) {
+                throw ( new Error(`Could not load addon ${name}`));
+            }
+            importedAddons.set(name, addon);
+        }
+        return addon;
+    }
+}
+
+export { XtermAddonImporter };