@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

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

@@ -0,0 +1,175 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+class File {
+    constructor(name) {
+        this.type = FileType.File;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.name = name;
+    }
+}
+class Directory {
+    constructor(name) {
+        this.type = FileType.Directory;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.name = name;
+        this.entries = ( new Map());
+    }
+}
+class InMemoryFileSystemProvider extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this._capabilities = 2  | 1024 ;
+        this.root = ( new Directory(''));
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._bufferedChanges = [];
+    }
+    get capabilities() { return this._capabilities; }
+    setReadOnly(readonly) {
+        const isReadonly = !!((this._capabilities & 2048) );
+        if (readonly !== isReadonly) {
+            this._capabilities = readonly ? 2048  | 1024  | 2
+                : 2  | 1024 ;
+            this._onDidChangeCapabilities.fire();
+        }
+    }
+    async stat(resource) {
+        return this._lookup(resource, false);
+    }
+    async readdir(resource) {
+        const entry = this._lookupAsDirectory(resource, false);
+        const result = [];
+        entry.entries.forEach((child, name) => result.push([name, child.type]));
+        return result;
+    }
+    async readFile(resource) {
+        const data = this._lookupAsFile(resource, false).data;
+        if (data) {
+            return data;
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async writeFile(resource, content, opts) {
+        const basename = resources.basename(resource);
+        const parent = this._lookupParentDirectory(resource);
+        let entry = parent.entries.get(basename);
+        if (entry instanceof Directory) {
+            throw createFileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
+        }
+        if (!entry && !opts.create) {
+            throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+        }
+        if (entry && opts.create && !opts.overwrite) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        if (!entry) {
+            entry = ( new File(basename));
+            parent.entries.set(basename, entry);
+            this._fireSoon({ type: 1 , resource });
+        }
+        entry.mtime = Date.now();
+        entry.size = content.byteLength;
+        entry.data = content;
+        this._fireSoon({ type: 0 , resource });
+    }
+    async rename(from, to, opts) {
+        if (!opts.overwrite && this._lookup(to, true)) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        const entry = this._lookup(from, false);
+        const oldParent = this._lookupParentDirectory(from);
+        const newParent = this._lookupParentDirectory(to);
+        const newName = resources.basename(to);
+        oldParent.entries.delete(entry.name);
+        entry.name = newName;
+        newParent.entries.set(newName, entry);
+        this._fireSoon({ type: 2 , resource: from }, { type: 1 , resource: to });
+    }
+    async delete(resource, opts) {
+        const dirname = resources.dirname(resource);
+        const basename = resources.basename(resource);
+        const parent = this._lookupAsDirectory(dirname, false);
+        if (parent.entries.has(basename)) {
+            parent.entries.delete(basename);
+            parent.mtime = Date.now();
+            parent.size -= 1;
+            this._fireSoon({ type: 0 , resource: dirname }, { resource, type: 2  });
+        }
+    }
+    async mkdir(resource) {
+        if (this._lookup(resource, true)) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        const basename = resources.basename(resource);
+        const dirname = resources.dirname(resource);
+        const parent = this._lookupAsDirectory(dirname, false);
+        const entry = ( new Directory(basename));
+        parent.entries.set(entry.name, entry);
+        parent.mtime = Date.now();
+        parent.size += 1;
+        this._fireSoon({ type: 0 , resource: dirname }, { type: 1 , resource });
+    }
+    _lookup(uri, silent) {
+        const parts = uri.path.split('/');
+        let entry = this.root;
+        for (const part of parts) {
+            if (!part) {
+                continue;
+            }
+            let child;
+            if (entry instanceof Directory) {
+                child = entry.entries.get(part);
+            }
+            if (!child) {
+                if (!silent) {
+                    throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+                }
+                else {
+                    return undefined;
+                }
+            }
+            entry = child;
+        }
+        return entry;
+    }
+    _lookupAsDirectory(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof Directory) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
+    }
+    _lookupAsFile(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof File) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
+    }
+    _lookupParentDirectory(uri) {
+        const dirname = resources.dirname(uri);
+        return this._lookupAsDirectory(dirname, false);
+    }
+    watch(resource, opts) {
+        return Disposable.None;
+    }
+    _fireSoon(...changes) {
+        this._bufferedChanges.push(...changes);
+        if (this._fireSoonHandle) {
+            clearTimeout(this._fireSoonHandle);
+        }
+        this._fireSoonHandle = setTimeout(() => {
+            this._onDidChangeFile.fire(this._bufferedChanges);
+            this._bufferedChanges.length = 0;
+        }, 5);
+    }
+}
+export { InMemoryFileSystemProvider };

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

@@ -0,0 +1,80 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ensureFileSystemProviderError, createFileSystemProviderError, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+async function readFileIntoStream(provider, resource, target, transformer, options, token) {
+    let error = undefined;
+    try {
+        await doReadFileIntoStream(provider, resource, target, transformer, options, token);
+    }
+    catch (err) {
+        error = err;
+    }
+    finally {
+        if (error && options.errorTransformer) {
+            error = options.errorTransformer(error);
+        }
+        if (typeof error !== 'undefined') {
+            target.error(error);
+        }
+        target.end();
+    }
+}
+async function doReadFileIntoStream(provider, resource, target, transformer, options, token) {
+    throwIfCancelled(token);
+    const handle = await provider.open(resource, { create: false });
+    try {
+        throwIfCancelled(token);
+        let totalBytesRead = 0;
+        let bytesRead = 0;
+        let allowedRemainingBytes = (options && typeof options.length === 'number') ? options.length : undefined;
+        let buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
+        let posInFile = options && typeof options.position === 'number' ? options.position : 0;
+        let posInBuffer = 0;
+        do {
+            bytesRead = await provider.read(handle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
+            posInFile += bytesRead;
+            posInBuffer += bytesRead;
+            totalBytesRead += bytesRead;
+            if (typeof allowedRemainingBytes === 'number') {
+                allowedRemainingBytes -= bytesRead;
+            }
+            if (posInBuffer === buffer.byteLength) {
+                await target.write(transformer(buffer));
+                buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
+                posInBuffer = 0;
+            }
+        } while (bytesRead > 0 && (typeof allowedRemainingBytes !== 'number' || allowedRemainingBytes > 0) && throwIfCancelled(token) && throwIfTooLarge(totalBytesRead, options));
+        if (posInBuffer > 0) {
+            let lastChunkLength = posInBuffer;
+            if (typeof allowedRemainingBytes === 'number') {
+                lastChunkLength = Math.min(posInBuffer, allowedRemainingBytes);
+            }
+            target.write(transformer(buffer.slice(0, lastChunkLength)));
+        }
+    }
+    catch (error) {
+        throw ensureFileSystemProviderError(error);
+    }
+    finally {
+        await provider.close(handle);
+    }
+}
+function throwIfCancelled(token) {
+    if (token.isCancellationRequested) {
+        throw canceled();
+    }
+    return true;
+}
+function throwIfTooLarge(totalBytesRead, options) {
+    if (options?.limits) {
+        if (typeof options.limits.memory === 'number' && totalBytesRead > options.limits.memory) {
+            throw createFileSystemProviderError(localize('fileTooLargeForHeapError', "To open a file of this size, you need to restart and allow to use more memory"), FileSystemProviderErrorCode.FileExceedsMemoryLimit);
+        }
+        if (typeof options.limits.size === 'number' && totalBytesRead > options.limits.size) {
+            throw createFileSystemProviderError(localize('fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
+        }
+    }
+    return true;
+}
+export { readFileIntoStream };

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

@@ -0,0 +1,69 @@
+import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+class AbstractWatcherClient extends Disposable {
+    constructor(onFileChanges, onLogMessage, verboseLogging, options) {
+        super();
+        this.onFileChanges = onFileChanges;
+        this.onLogMessage = onLogMessage;
+        this.verboseLogging = verboseLogging;
+        this.options = options;
+        this.watcherDisposables = this._register(( new MutableDisposable()));
+        this.requests = undefined;
+        this.restartCounter = 0;
+    }
+    init() {
+        const disposables = ( new DisposableStore());
+        this.watcherDisposables.value = disposables;
+        this.watcher = this.createWatcher(disposables);
+        this.watcher.setVerboseLogging(this.verboseLogging);
+        disposables.add(this.watcher.onDidChangeFile(changes => this.onFileChanges(changes)));
+        disposables.add(this.watcher.onDidLogMessage(msg => this.onLogMessage(msg)));
+        disposables.add(this.watcher.onDidError(error => this.onError(error)));
+    }
+    onError(error) {
+        if (this.options.restartOnError) {
+            if (this.restartCounter < AbstractWatcherClient.MAX_RESTARTS && this.requests) {
+                this.error(`restarting watcher after error: ${error}`);
+                this.restart(this.requests);
+            }
+            else {
+                this.error(`gave up attempting to restart watcher after error: ${error}`);
+            }
+        }
+        else {
+            this.error(error);
+        }
+    }
+    restart(requests) {
+        this.restartCounter++;
+        this.init();
+        this.watch(requests);
+    }
+    async watch(requests) {
+        this.requests = requests;
+        await this.watcher?.watch(requests);
+    }
+    async setVerboseLogging(verboseLogging) {
+        this.verboseLogging = verboseLogging;
+        await this.watcher?.setVerboseLogging(verboseLogging);
+    }
+    error(message) {
+        this.onLogMessage({ type: 'error', message: `[File Watcher (${this.options.type})] ${message}` });
+    }
+    trace(message) {
+        this.onLogMessage({ type: 'trace', message: `[File Watcher (${this.options.type})] ${message}` });
+    }
+    dispose() {
+        this.watcher = undefined;
+        return super.dispose();
+    }
+}
+AbstractWatcherClient.MAX_RESTARTS = 5;
+function normalizeWatcherPattern(path, pattern) {
+    if (typeof pattern === 'string' && !pattern.startsWith(GLOBSTAR) && !isAbsolute(pattern)) {
+        return { base: path, pattern };
+    }
+    return pattern;
+}
+export { AbstractWatcherClient, normalizeWatcherPattern };

package/dist/vscode/vs/platform/keyboardLayout/common/keyboardConfig.js

@@ -0,0 +1,42 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+function readKeyboardConfig(configurationService) {
+    const keyboard = configurationService.getValue('keyboard');
+    const dispatch = ((keyboard?.dispatch === 'keyCode' ? 1  : 0) );
+    const mapAltGrToCtrlAlt = Boolean(keyboard?.mapAltGrToCtrlAlt);
+    return { dispatch, mapAltGrToCtrlAlt };
+}
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+const keyboardConfiguration = {
+    'id': 'keyboard',
+    'order': 15,
+    'type': 'object',
+    'title': ( nls.localize('keyboardConfigurationTitle', "Keyboard")),
+    'properties': {
+        'keyboard.dispatch': {
+            scope: 1 ,
+            type: 'string',
+            enum: ['code', 'keyCode'],
+            default: 'code',
+            markdownDescription: ( nls.localize(
+                'dispatch',
+                "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."
+            )),
+            included: OS === 2  || OS === 3
+        },
+        'keyboard.mapAltGrToCtrlAlt': {
+            scope: 1 ,
+            type: 'boolean',
+            default: false,
+            markdownDescription: ( nls.localize(
+                'mapAltGrToCtrlAlt',
+                "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+."
+            )),
+            included: OS === 1
+        }
+    }
+};
+configurationRegistry.registerConfiguration(keyboardConfiguration);
+export { readKeyboardConfig };

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

@@ -0,0 +1,12 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IKeyboardLayoutService = ( createDecorator('keyboardLayoutService'));
+function getKeyboardLayoutId(layout) {
+    if (layout.name) {
+        return layout.name;
+    }
+    if (layout.id) {
+        return layout.id;
+    }
+    return layout.layout;
+}
+export { IKeyboardLayoutService, getKeyboardLayoutId };

package/dist/vscode/vs/platform/keyboardLayout/common/keyboardMapper.js

@@ -0,0 +1,23 @@
+class CachedKeyboardMapper {
+    constructor(actual) {
+        this._actual = actual;
+        this._cache = ( new Map());
+    }
+    dumpDebugInfo() {
+        return this._actual.dumpDebugInfo();
+    }
+    resolveKeyboardEvent(keyboardEvent) {
+        return this._actual.resolveKeyboardEvent(keyboardEvent);
+    }
+    resolveKeybinding(keybinding) {
+        const hashCode = keybinding.getHashCode();
+        const resolved = this._cache.get(hashCode);
+        if (!resolved) {
+            const r = this._actual.resolveKeybinding(keybinding);
+            this._cache.set(hashCode, r);
+            return r;
+        }
+        return resolved;
+    }
+}
+export { CachedKeyboardMapper };

package/dist/vscode/vs/platform/product/common/productService.js

@@ -0,0 +1,4 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IProductService = ( createDecorator('productService'));
+const productSchemaId = 'vscode://schemas/vscode-product';
+export { IProductService, productSchemaId };

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

@@ -0,0 +1,17 @@
+var RemoteAuthorityResolverErrorCode;
+( (function(RemoteAuthorityResolverErrorCode) {
+    RemoteAuthorityResolverErrorCode["Unknown"] = "Unknown";
+    RemoteAuthorityResolverErrorCode["NotAvailable"] = "NotAvailable";
+    RemoteAuthorityResolverErrorCode["TemporarilyNotAvailable"] = "TemporarilyNotAvailable";
+    RemoteAuthorityResolverErrorCode["NoResolverFound"] = "NoResolverFound";
+})(
+    RemoteAuthorityResolverErrorCode || (RemoteAuthorityResolverErrorCode = {})
+));
+function getRemoteAuthorityPrefix(remoteAuthority) {
+    const plusIndex = remoteAuthority.indexOf('+');
+    if (plusIndex === -1) {
+        return remoteAuthority;
+    }
+    return remoteAuthority.substring(0, plusIndex);
+}
+export { RemoteAuthorityResolverErrorCode, getRemoteAuthorityPrefix };

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

@@ -0,0 +1,18 @@
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+function getRemoteAuthority(uri) {
+    return uri.scheme === Schemas.vscodeRemote ? uri.authority : undefined;
+}
+function getRemoteName(authority) {
+    if (!authority) {
+        return undefined;
+    }
+    const pos = authority.indexOf('+');
+    if (pos < 0) {
+        return authority;
+    }
+    return authority.substr(0, pos);
+}
+function getRemoteServerRootPath(product) {
+    return `/${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`;
+}
+export { getRemoteAuthority, getRemoteName, getRemoteServerRootPath };

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

@@ -0,0 +1,25 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { request } from '../../../base/parts/request/browser/request.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+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);
+        this.configurationService = configurationService;
+    }
+    async request(options, token) {
+        if (!options.proxyAuthorization) {
+            options.proxyAuthorization = this.configurationService.getValue('http.proxyAuthorization');
+        }
+        return this.logAndRequest('browser', options, () => request(options, token));
+    }
+    async resolveProxy(url) {
+        return undefined;
+    }
+};
+RequestService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ILoggerService))
+], RequestService));
+export { RequestService };

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

@@ -0,0 +1,50 @@
+import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { CONTEXT_LOG_LEVEL, LogLevelToString, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+const IRequestService = ( createDecorator('requestService'));
+class LoggableHeaders {
+    constructor(original) {
+        this.original = original;
+    }
+    toJSON() {
+        if (!this.headers) {
+            const headers = Object.create(null);
+            for (const key in this.original) {
+                if (key.toLowerCase() === 'authorization' || key.toLowerCase() === 'proxy-authorization') {
+                    headers[key] = '*****';
+                }
+                else {
+                    headers[key] = this.original[key];
+                }
+            }
+            this.headers = headers;
+        }
+        return this.headers;
+    }
+}
+class AbstractRequestService extends Disposable {
+    constructor(remote, loggerService) {
+        super();
+        this.counter = 0;
+        this.logger = loggerService.createLogger(remote ? 'remotenetwork' : 'network', {
+            name: remote ? ( localize('remote request', "Network Requests (Remote)")) : ( localize('request', "Network Requests")),
+            when: ( CONTEXT_LOG_LEVEL.isEqualTo(LogLevelToString(LogLevel.Trace))).serialize()
+        });
+    }
+    async logAndRequest(stack, options, request) {
+        const prefix = `${stack} #${++this.counter}: ${options.url}`;
+        this.logger.trace(`${prefix} - begin`, options.type, ( new LoggableHeaders(options.headers ?? {})));
+        try {
+            const result = await request();
+            this.logger.trace(`${prefix} - end`, options.type, result.res.statusCode, result.res.headers);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`${prefix} - error`, options.type, getErrorMessage(error));
+            throw error;
+        }
+    }
+}
+export { AbstractRequestService, IRequestService };

package/dist/vscode/vs/platform/telemetry/common/telemetryUtils.js

@@ -0,0 +1,119 @@
+import { cloneAndChange } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { getRemoteName } from '../../remote/common/remoteHosts.js';
+import { TELEMETRY_SETTING_ID, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+class TelemetryTrustedValue {
+    constructor(value) {
+        this.value = value;
+    }
+}
+class NullEndpointTelemetryService {
+    async publicLog(_endpoint, _eventName, _data) {
+    }
+    async publicLogError(_endpoint, _errorEventName, _data) {
+    }
+}
+const extensionTelemetryLogChannelId = 'extensionTelemetryLog';
+function supportsTelemetry(productService, environmentService) {
+    if (!environmentService.isBuilt && !environmentService.disableTelemetry) {
+        return true;
+    }
+    return !(environmentService.disableTelemetry || !productService.enableTelemetry || environmentService.extensionTestsLocationURI);
+}
+function getTelemetryLevel(configurationService) {
+    const newConfig = configurationService.getValue(TELEMETRY_SETTING_ID);
+    const crashReporterConfig = configurationService.getValue(TELEMETRY_CRASH_REPORTER_SETTING_ID);
+    const oldConfig = configurationService.getValue(TELEMETRY_OLD_SETTING_ID);
+    if (oldConfig === false || crashReporterConfig === false) {
+        return 0 ;
+    }
+    switch (newConfig ?? "all" ) {
+        case "all" :
+            return 3 ;
+        case "error" :
+            return 2 ;
+        case "crash" :
+            return 1 ;
+        case "off" :
+            return 0 ;
+    }
+}
+const telemetryAllowedAuthorities = ( new Set(
+    ['ssh-remote', 'dev-container', 'attached-container', 'wsl', 'tunnel', 'codespaces', 'amlext']
+));
+function cleanRemoteAuthority(remoteAuthority) {
+    if (!remoteAuthority) {
+        return 'none';
+    }
+    const remoteName = getRemoteName(remoteAuthority);
+    return telemetryAllowedAuthorities.has(remoteName) ? remoteName : 'other';
+}
+function anonymizeFilePaths(stack, cleanupPatterns) {
+    if (!stack || (!stack.includes('/') && !stack.includes('\\'))) {
+        return stack;
+    }
+    let updatedStack = stack;
+    const cleanUpIndexes = [];
+    for (const regexp of cleanupPatterns) {
+        while (true) {
+            const result = regexp.exec(stack);
+            if (!result) {
+                break;
+            }
+            cleanUpIndexes.push([result.index, regexp.lastIndex]);
+        }
+    }
+    const nodeModulesRegex = /^[\\\/]?(node_modules|node_modules\.asar)[\\\/]/;
+    const fileRegex = /(file:\/\/)?([a-zA-Z]:(\\\\|\\|\/)|(\\\\|\\|\/))?([\w-\._]+(\\\\|\\|\/))+[\w-\._]*/g;
+    let lastIndex = 0;
+    updatedStack = '';
+    while (true) {
+        const result = fileRegex.exec(stack);
+        if (!result) {
+            break;
+        }
+        const overlappingRange = ( cleanUpIndexes.some(([start, end]) => result.index < end && start < fileRegex.lastIndex));
+        if (!nodeModulesRegex.test(result[0]) && !overlappingRange) {
+            updatedStack += stack.substring(lastIndex, result.index) + '<REDACTED: user-file-path>';
+            lastIndex = fileRegex.lastIndex;
+        }
+    }
+    if (lastIndex < stack.length) {
+        updatedStack += stack.substr(lastIndex);
+    }
+    return updatedStack;
+}
+function removePropertiesWithPossibleUserInfo(property) {
+    if (!property) {
+        return property;
+    }
+    const userDataRegexes = [
+        { label: 'Google API Key', regex: /AIza[A-Za-z0-9_\\\-]{35}/ },
+        { label: 'Slack Token', regex: /xox[pbar]\-[A-Za-z0-9]/ },
+        { label: 'Generic Secret', regex: /(key|token|sig|secret|signature|password|passwd|pwd|android:value)[^a-zA-Z0-9]/i },
+        { label: 'Email', regex: /@[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+/ }
+    ];
+    for (const secretRegex of userDataRegexes) {
+        if (secretRegex.regex.test(property)) {
+            return `<REDACTED: ${secretRegex.label}>`;
+        }
+    }
+    return property;
+}
+function cleanData(data, cleanUpPatterns) {
+    return cloneAndChange(data, value => {
+        if (value instanceof TelemetryTrustedValue) {
+            return value.value;
+        }
+        if (typeof value === 'string') {
+            let updatedProperty = value.replaceAll('%20', ' ');
+            updatedProperty = anonymizeFilePaths(updatedProperty, cleanUpPatterns);
+            for (const regexp of cleanUpPatterns) {
+                updatedProperty = updatedProperty.replace(regexp, '');
+            }
+            updatedProperty = removePropertiesWithPossibleUserInfo(updatedProperty);
+            return updatedProperty;
+        }
+        return undefined;
+    });
+}
+export { NullEndpointTelemetryService, TelemetryTrustedValue, cleanData, cleanRemoteAuthority, extensionTelemetryLogChannelId, getTelemetryLevel, supportsTelemetry };