@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/platform/extensionResourceLoader/common/extensionResourceLoader.js

@@ -24,17 +24,25 @@ class AbstractExtensionResourceLoaderService {
     get supportsExtensionGalleryResources() {
         return this._extensionGalleryResourceUrlTemplate !== undefined;
     }
-    getExtensionGalleryResourceURL(galleryExtension, path) {
+    getExtensionGalleryResourceURL({ publisher, name, version, targetPlatform }, path) {
         if (this._extensionGalleryResourceUrlTemplate) {
-            const uri = ( URI.parse(
-                format2(this._extensionGalleryResourceUrlTemplate, { publisher: galleryExtension.publisher, name: galleryExtension.name, version: galleryExtension.version, path: 'extension' })
-            ));
+            const uri = ( URI.parse(format2(this._extensionGalleryResourceUrlTemplate, {
+                publisher,
+                name,
+                version: targetPlatform !== undefined
+                    && targetPlatform !== "undefined"
+                    && targetPlatform !== "unknown"
+                    && targetPlatform !== "universal"
+                    ? `${version}+${targetPlatform}`
+                    : version,
+                path: 'extension'
+            })));
             return this._isWebExtensionResourceEndPoint(uri) ? uri.with({ scheme: RemoteAuthorities.getPreferredWebSchema() }) : uri;
         }
         return undefined;
     }
     isExtensionGalleryResource(uri) {
-        return this._extensionGalleryAuthority && this._extensionGalleryAuthority === this._getExtensionGalleryAuthority(uri);
+        return !!this._extensionGalleryAuthority && this._extensionGalleryAuthority === this._getExtensionGalleryAuthority(uri);
     }
     async getExtensionGalleryRequestHeaders() {
         const headers = {

package/dist/vscode/vs/platform/files/common/fileService.js

@@ -10,7 +10,7 @@ import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-edito
 import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
-import { isAbsolutePath, extUri, extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isAbsolutePath, joinPath, dirname, basename, extUri, extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { isReadableStream, peekStream, peekReadable, consumeStream, transform, newWriteableStream, isReadableBufferedStream, listenStream } from 'monaco-editor/esm/vs/base/common/stream.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, ensureFileSystemProviderError, FileType, FilePermission, etag, FileOperationEvent, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileCloneCapability } from 'monaco-editor/esm/vs/platform/files/common/files.js';
@@ -169,6 +169,7 @@ let FileService = class FileService extends Disposable {
             ctime: stat.ctime,
             size: stat.size,
             readonly: Boolean((stat.permissions ?? 0) & FilePermission.Readonly) || Boolean(provider.capabilities & 2048 ),
+            locked: Boolean((stat.permissions ?? 0) & FilePermission.Locked),
             etag: etag({ mtime: stat.mtime, size: stat.size }),
             children: undefined
         };
@@ -272,7 +273,13 @@ let FileService = class FileService extends Disposable {
                 await this.doWriteUnbuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream);
             }
             else {
-                await this.doWriteBuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
+                const contents = bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream;
+                if (options?.atomic !== false && options?.atomic?.postfix) {
+                    await this.doWriteBufferedAtomic(provider, resource, joinPath(dirname(resource), `${basename(resource)}${options.atomic.postfix}`), options, contents);
+                }
+                else {
+                    await this.doWriteBuffered(provider, resource, options, contents);
+                }
             }
             this._onDidRunOperation.fire(( new FileOperationEvent(resource, 4 )));
         }
@@ -286,6 +293,15 @@ let FileService = class FileService extends Disposable {
         if (unlock && !((provider.capabilities & 8192) )) {
             throw new Error(localize('writeFailedUnlockUnsupported', "Unable to unlock file '{0}' because provider does not support it.", this.resourceForError(resource)));
         }
+        const atomic = !!options?.atomic;
+        if (atomic) {
+            if (!((provider.capabilities & 32768) )) {
+                throw new Error(localize('writeFailedAtomicUnsupported', "Unable to atomically write file '{0}' because provider does not support it.", this.resourceForError(resource)));
+            }
+            if (unlock) {
+                throw new Error(localize('writeFailedAtomicUnlock', "Unable to unlock file '{0}' because atomic write is enabled.", this.resourceForError(resource)));
+            }
+        }
         let stat = undefined;
         try {
             stat = await provider.stat(resource);
@@ -646,6 +662,13 @@ let FileService = class FileService extends Disposable {
         if (useTrash && !((provider.capabilities & 4096) )) {
             throw new Error(localize('deleteFailedTrashUnsupported', "Unable to delete file '{0}' via trash because provider does not support it.", this.resourceForError(resource)));
         }
+        const atomic = options?.atomic;
+        if (atomic && !((provider.capabilities & 65536) )) {
+            throw new Error(localize('deleteFailedAtomicUnsupported', "Unable to delete file '{0}' atomically because provider does not support it.", this.resourceForError(resource)));
+        }
+        if (useTrash && atomic) {
+            throw new Error(localize('deleteFailedTrashAndAtomicUnsupported', "Unable to atomically delete file '{0}' because using trash is enabled.", this.resourceForError(resource)));
+        }
         let stat = undefined;
         try {
             stat = await provider.stat(resource);
@@ -671,7 +694,8 @@ let FileService = class FileService extends Disposable {
         const provider = await this.doValidateDelete(resource, options);
         const useTrash = !!options?.useTrash;
         const recursive = !!options?.recursive;
-        await provider.delete(resource, { recursive, useTrash });
+        const atomic = options?.atomic ?? false;
+        await provider.delete(resource, { recursive, useTrash, atomic });
         this._onDidRunOperation.fire(( new FileOperationEvent(resource, 1 )));
     }
     async cloneFile(source, target) {
@@ -740,6 +764,20 @@ let FileService = class FileService extends Disposable {
         }
         this.activeWatchers.clear();
     }
+    async doWriteBufferedAtomic(provider, resource, tempResource, options, readableOrStreamOrBufferedStream) {
+        await this.doWriteBuffered(provider, tempResource, options, readableOrStreamOrBufferedStream);
+        try {
+            await provider.rename(tempResource, resource, { overwrite: true });
+        }
+        catch (error) {
+            try {
+                await provider.delete(tempResource, { recursive: false, useTrash: false, atomic: false });
+            }
+            catch (error) {
+            }
+            throw error;
+        }
+    }
     async doWriteBuffered(provider, resource, options, readableOrStreamOrBufferedStream) {
         return this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(async () => {
             const handle = await provider.open(resource, { create: true, unlock: options?.unlock ?? false });
@@ -826,7 +864,7 @@ let FileService = class FileService extends Disposable {
         else {
             buffer = readableToBuffer(bufferOrReadableOrStreamOrBufferedStream);
         }
-        await provider.writeFile(resource, buffer.buffer, { create: true, overwrite: true, unlock: options?.unlock ?? false });
+        await provider.writeFile(resource, buffer.buffer, { create: true, overwrite: true, unlock: options?.unlock ?? false, atomic: options?.atomic ?? false });
     }
     async doPipeBuffered(sourceProvider, source, targetProvider, target) {
         return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeBufferedQueued(sourceProvider, source, targetProvider, target));
@@ -865,7 +903,7 @@ let FileService = class FileService extends Disposable {
         return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target));
     }
     async doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target) {
-        return targetProvider.writeFile(target, await sourceProvider.readFile(source), { create: true, overwrite: true, unlock: false });
+        return targetProvider.writeFile(target, await sourceProvider.readFile(source), { create: true, overwrite: true, unlock: false, atomic: false });
     }
     async doPipeUnbufferedToBuffered(sourceProvider, source, targetProvider, target) {
         return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeUnbufferedToBufferedQueued(sourceProvider, source, targetProvider, target));

package/dist/vscode/vs/platform/files/common/files.js

@@ -17,7 +17,9 @@ var FileSystemProviderCapabilities;
     FileSystemProviderCapabilities[FileSystemProviderCapabilities["Trash"] = 4096] = "Trash";
     FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileWriteUnlock"] = 8192] = "FileWriteUnlock";
     FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicRead"] = 16384] = "FileAtomicRead";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileClone"] = 32768] = "FileClone";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicWrite"] = 32768] = "FileAtomicWrite";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicDelete"] = 65536] = "FileAtomicDelete";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileClone"] = 131072] = "FileClone";
 })(FileSystemProviderCapabilities || (FileSystemProviderCapabilities = {})));
 var FileChangeType;
 ( (function(FileChangeType) {

package/dist/vscode/vs/platform/languagePacks/common/languagePacks.js

@@ -1,3 +1,6 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+function getLocale(extension) {
+    return extension.tags.find(t => t.startsWith('lp-'))?.split('lp-')[1];
+}
 const ILanguagePackService = ( createDecorator('languagePackService'));
-export { ILanguagePackService };
+export { ILanguagePackService, getLocale };

package/dist/vscode/vs/platform/log/common/bufferLog.js

@@ -0,0 +1,34 @@
+import { AbstractMessageLogger, DEFAULT_LOG_LEVEL, log } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+class BufferLogger extends AbstractMessageLogger {
+    constructor(logLevel = DEFAULT_LOG_LEVEL) {
+        super();
+        this.buffer = [];
+        this._logger = undefined;
+        this.setLevel(logLevel);
+        this._register(this.onDidChangeLogLevel(level => {
+            this._logger?.setLevel(level);
+        }));
+    }
+    set logger(logger) {
+        this._logger = logger;
+        for (const { level, message } of this.buffer) {
+            log(logger, level, message);
+        }
+        this.buffer = [];
+    }
+    log(level, message) {
+        if (this._logger) {
+            log(this._logger, level, message);
+        }
+        else if (this.getLevel() <= level) {
+            this.buffer.push({ level, message });
+        }
+    }
+    dispose() {
+        this._logger?.dispose();
+    }
+    flush() {
+        this._logger?.flush();
+    }
+}
+export { BufferLogger };

package/dist/vscode/vs/platform/log/common/fileLog.js

@@ -0,0 +1,105 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { joinPath, dirname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { whenProviderRegistered, IFileService, ByteSize } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { BufferLogger } from './bufferLog.js';
+import { AbstractLoggerService, AbstractMessageLogger, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+const MAX_FILE_SIZE = 5 * ByteSize.MB;
+let FileLogger = class FileLogger extends AbstractMessageLogger {
+    constructor(resource, level, donotUseFormatters, fileService) {
+        super();
+        this.resource = resource;
+        this.donotUseFormatters = donotUseFormatters;
+        this.fileService = fileService;
+        this.backupIndex = 1;
+        this.buffer = '';
+        this.setLevel(level);
+        this.flushDelayer = ( new ThrottledDelayer(100 ));
+        this.initializePromise = this.initialize();
+    }
+    async flush() {
+        if (!this.buffer) {
+            return;
+        }
+        await this.initializePromise;
+        let content = await this.loadContent();
+        if (content.length > MAX_FILE_SIZE) {
+            await this.fileService.writeFile(this.getBackupResource(), VSBuffer.fromString(content));
+            content = '';
+        }
+        if (this.buffer) {
+            content += this.buffer;
+            this.buffer = '';
+            await this.fileService.writeFile(this.resource, VSBuffer.fromString(content));
+        }
+    }
+    async initialize() {
+        try {
+            await this.fileService.createFile(this.resource);
+        }
+        catch (error) {
+            if (error.fileOperationResult !== 3 ) {
+                throw error;
+            }
+        }
+    }
+    log(level, message) {
+        if (this.donotUseFormatters) {
+            this.buffer += message;
+        }
+        else {
+            this.buffer += `${this.getCurrentTimestamp()} [${this.stringifyLogLevel(level)}] ${message}\n`;
+        }
+        this.flushDelayer.trigger(() => this.flush());
+    }
+    getCurrentTimestamp() {
+        const toTwoDigits = (v) => v < 10 ? `0${v}` : v;
+        const toThreeDigits = (v) => v < 10 ? `00${v}` : v < 100 ? `0${v}` : v;
+        const currentTime = ( new Date());
+        return `${currentTime.getFullYear()}-${toTwoDigits(currentTime.getMonth() + 1)}-${toTwoDigits(currentTime.getDate())} ${toTwoDigits(currentTime.getHours())}:${toTwoDigits(currentTime.getMinutes())}:${toTwoDigits(currentTime.getSeconds())}.${toThreeDigits(currentTime.getMilliseconds())}`;
+    }
+    getBackupResource() {
+        this.backupIndex = this.backupIndex > 5 ? 1 : this.backupIndex;
+        return joinPath(dirname(this.resource), `${basename(this.resource)}_${this.backupIndex++}`);
+    }
+    async loadContent() {
+        try {
+            const content = await this.fileService.readFile(this.resource);
+            return ( content.value.toString());
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    stringifyLogLevel(level) {
+        switch (level) {
+            case LogLevel.Debug: return 'debug';
+            case LogLevel.Error: return 'error';
+            case LogLevel.Info: return 'info';
+            case LogLevel.Trace: return 'trace';
+            case LogLevel.Warning: return 'warning';
+        }
+        return '';
+    }
+};
+FileLogger = ( __decorate([
+    ( __param(3, IFileService))
+], FileLogger));
+class FileLoggerService extends AbstractLoggerService {
+    constructor(logLevel, logsHome, fileService) {
+        super(logLevel, logsHome);
+        this.fileService = fileService;
+    }
+    doCreateLogger(resource, logLevel, options) {
+        const logger = ( new BufferLogger(logLevel));
+        whenProviderRegistered(resource, this.fileService).then(() => logger.logger = ( new FileLogger(
+            resource,
+            logger.getLevel(),
+            !!options?.donotUseFormatters,
+            this.fileService
+        )));
+        return logger;
+    }
+}
+export { FileLoggerService };

package/dist/vscode/vs/platform/quickinput/browser/quickPickPin.js

@@ -0,0 +1,94 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+const pinButtonClass = ThemeIcon.asClassName(Codicon.pin);
+const pinnedButtonClass = ThemeIcon.asClassName(Codicon.pinned);
+const buttonClasses = [pinButtonClass, pinnedButtonClass];
+async function showWithPinnedItems(storageService, storageKey, quickPick, filterDuplicates) {
+    const itemsWithoutPinned = quickPick.items;
+    let itemsWithPinned = _formatPinnedItems(storageKey, quickPick, storageService, undefined, filterDuplicates);
+    quickPick.onDidTriggerItemButton(async (buttonEvent) => {
+        const expectedButton = buttonEvent.button.iconClass && buttonClasses.includes(buttonEvent.button.iconClass);
+        if (expectedButton) {
+            quickPick.items = itemsWithoutPinned;
+            itemsWithPinned = _formatPinnedItems(storageKey, quickPick, storageService, buttonEvent.item, filterDuplicates);
+            quickPick.items = quickPick.value ? itemsWithoutPinned : itemsWithPinned;
+        }
+    });
+    quickPick.onDidChangeValue(async (value) => {
+        if (quickPick.items === itemsWithPinned && value) {
+            quickPick.items = itemsWithoutPinned;
+        }
+        else if (quickPick.items === itemsWithoutPinned && !value) {
+            quickPick.items = itemsWithPinned;
+        }
+    });
+    quickPick.items = quickPick.value ? itemsWithoutPinned : itemsWithPinned;
+    quickPick.show();
+}
+function _formatPinnedItems(storageKey, quickPick, storageService, changedItem, filterDuplicates) {
+    const formattedItems = [];
+    let pinnedItems;
+    if (changedItem) {
+        pinnedItems = updatePinnedItems(storageKey, changedItem, storageService);
+    }
+    else {
+        pinnedItems = getPinnedItems(storageKey, storageService);
+    }
+    if (pinnedItems.length) {
+        formattedItems.push({ type: 'separator', label: ( localize("terminal.commands.pinned", 'pinned')) });
+    }
+    const pinnedIds = ( new Set());
+    for (const itemToFind of pinnedItems) {
+        const itemToPin = quickPick.items.find(item => itemsMatch(item, itemToFind));
+        if (itemToPin) {
+            const pinnedItemId = getItemIdentifier(itemToPin);
+            const pinnedItem = Object.assign({}, itemToPin);
+            if (!filterDuplicates || !( pinnedIds.has(pinnedItemId))) {
+                pinnedIds.add(pinnedItemId);
+                updateButtons(pinnedItem, false);
+                formattedItems.push(pinnedItem);
+            }
+        }
+    }
+    for (const item of quickPick.items) {
+        updateButtons(item, true);
+        formattedItems.push(item);
+    }
+    return formattedItems;
+}
+function getItemIdentifier(item) {
+    return item.type === 'separator' ? '' : item.id || `${item.label}${item.description}${item.detail}}`;
+}
+function updateButtons(item, removePin) {
+    if (item.type === 'separator') {
+        return;
+    }
+    const newButtons = item.buttons?.filter(button => button.iconClass && !buttonClasses.includes(button.iconClass)) ?? [];
+    newButtons.unshift({
+        iconClass: removePin ? pinButtonClass : pinnedButtonClass,
+        tooltip: removePin ? ( localize('pinCommand', "Pin command")) : ( localize('pinnedCommand', "Pinned command")),
+        alwaysVisible: false
+    });
+    item.buttons = newButtons;
+}
+function itemsMatch(itemA, itemB) {
+    return getItemIdentifier(itemA) === getItemIdentifier(itemB);
+}
+function updatePinnedItems(storageKey, changedItem, storageService) {
+    const removePin = changedItem.buttons?.find(b => b.iconClass === pinnedButtonClass);
+    let items = getPinnedItems(storageKey, storageService);
+    if (removePin) {
+        items = items.filter(item => getItemIdentifier(item) !== getItemIdentifier(changedItem));
+    }
+    else {
+        items.push(changedItem);
+    }
+    storageService.store(storageKey, JSON.stringify(items), 1 , 1 );
+    return items;
+}
+function getPinnedItems(storageKey, storageService) {
+    const items = storageService.get(storageKey, 1 );
+    return items ? JSON.parse(items) : [];
+}
+export { showWithPinnedItems };

package/dist/vscode/vs/platform/remote/common/remoteAuthorityResolver.js

@@ -1,5 +1,24 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const IRemoteAuthorityResolverService = ( createDecorator('remoteAuthorityResolverService'));
+class ManagedRemoteConnection {
+    constructor(id) {
+        this.id = id;
+        this.type = 1 ;
+    }
+    toString() {
+        return `Managed(${this.id})`;
+    }
+}
+class WebSocketRemoteConnection {
+    constructor(host, port) {
+        this.host = host;
+        this.port = port;
+        this.type = 0 ;
+    }
+    toString() {
+        return `WebSocket(${this.host}:${this.port})`;
+    }
+}
 var RemoteAuthorityResolverErrorCode;
 ( (function(RemoteAuthorityResolverErrorCode) {
     RemoteAuthorityResolverErrorCode["Unknown"] = "Unknown";
@@ -16,4 +35,4 @@ function getRemoteAuthorityPrefix(remoteAuthority) {
     }
     return remoteAuthority.substring(0, plusIndex);
 }
-export { IRemoteAuthorityResolverService, RemoteAuthorityResolverErrorCode, getRemoteAuthorityPrefix };
+export { IRemoteAuthorityResolverService, ManagedRemoteConnection, RemoteAuthorityResolverErrorCode, WebSocketRemoteConnection, getRemoteAuthorityPrefix };

package/dist/vscode/vs/platform/request/browser/requestService.js

@@ -5,7 +5,7 @@ import { ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js'
 import { AbstractRequestService } from '../common/request.js';
 let RequestService = class RequestService extends AbstractRequestService {
     constructor(configurationService, loggerService) {
-        super(false, loggerService);
+        super(loggerService);
         this.configurationService = configurationService;
     }
     async request(options, token) {

package/dist/vscode/vs/platform/request/common/request.js

@@ -25,11 +25,11 @@ class LoggableHeaders {
     }
 }
 class AbstractRequestService extends Disposable {
-    constructor(remote, loggerService) {
+    constructor(loggerService) {
         super();
         this.counter = 0;
-        this.logger = loggerService.createLogger(remote ? 'remotenetwork' : 'network', {
-            name: remote ? ( localize('remote request', "Network Requests (Remote)")) : ( localize('request', "Network Requests")),
+        this.logger = loggerService.createLogger('network', {
+            name: ( localize('request', "Network Requests")),
             when: ( CONTEXT_LOG_LEVEL.isEqualTo(LogLevelToString(LogLevel.Trace))).serialize()
         });
     }

package/dist/vscode/vs/platform/storage/common/storage.js

@@ -109,6 +109,9 @@ class AbstractStorageService extends Disposable {
     getNumber(key, scope, fallbackValue) {
         return this.getStorage(scope)?.getNumber(key, fallbackValue);
     }
+    getObject(key, scope, fallbackValue) {
+        return this.getStorage(scope)?.getObject(key, fallbackValue);
+    }
     store(key, value, scope, target) {
         if (isUndefinedOrNull(value)) {
             this.remove(key, scope);

package/dist/vscode/vs/platform/terminal/common/capabilities/bufferMarkCapability.js

@@ -0,0 +1,39 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+class BufferMarkCapability {
+    constructor(_terminal) {
+        this._terminal = _terminal;
+        this.type = 4 ;
+        this._idToMarkerMap = ( new Map());
+        this._anonymousMarkers = ( new Map());
+        this._onMarkAdded = ( new Emitter());
+        this.onMarkAdded = this._onMarkAdded.event;
+    }
+    *markers() {
+        for (const m of ( this._idToMarkerMap.values())) {
+            yield m;
+        }
+        for (const m of ( this._anonymousMarkers.values())) {
+            yield m;
+        }
+    }
+    addMark(properties) {
+        const marker = properties?.marker || this._terminal.registerMarker();
+        const id = properties?.id;
+        if (!marker) {
+            return;
+        }
+        if (id) {
+            this._idToMarkerMap.set(id, marker);
+            marker.onDispose(() => this._idToMarkerMap.delete(id));
+        }
+        else {
+            this._anonymousMarkers.set(marker.id, marker);
+            marker.onDispose(() => this._anonymousMarkers.delete(marker.id));
+        }
+        this._onMarkAdded.fire({ marker, id, hidden: properties?.hidden, hoverMessage: properties?.hoverMessage });
+    }
+    getMark(id) {
+        return this._idToMarkerMap.get(id);
+    }
+}
+export { BufferMarkCapability };