@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/services/preferences/common/preferencesValidation.js

@@ -1,393 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
-import { isStringArray, isString, isUndefinedOrNull, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
-function canBeType(propTypes, ...types) {
-    return ( types.some(t => propTypes.includes(t)));
-}
-function isNullOrEmpty(value) {
-    return value === '' || isUndefinedOrNull(value);
-}
-function createValidator(prop) {
-    const type = Array.isArray(prop.type) ? prop.type : [prop.type];
-    const isNullable = canBeType(type, 'null');
-    const isNumeric = (canBeType(type, 'number') || canBeType(type, 'integer')) && (type.length === 1 || type.length === 2 && isNullable);
-    const numericValidations = getNumericValidators(prop);
-    const stringValidations = getStringValidators(prop);
-    const arrayValidator = getArrayValidator(prop);
-    const objectValidator = getObjectValidator(prop);
-    return value => {
-        if (isNullable && isNullOrEmpty(value)) {
-            return '';
-        }
-        const errors = [];
-        if (arrayValidator) {
-            const err = arrayValidator(value);
-            if (err) {
-                errors.push(err);
-            }
-        }
-        if (objectValidator) {
-            const err = objectValidator(value);
-            if (err) {
-                errors.push(err);
-            }
-        }
-        if (prop.type === 'boolean' && value !== true && value !== false) {
-            errors.push(( nls.localize('validations.booleanIncorrectType', 'Incorrect type. Expected "boolean".')));
-        }
-        if (isNumeric) {
-            if (isNullOrEmpty(value) || typeof value === 'boolean' || Array.isArray(value) || isNaN(+value)) {
-                errors.push(( nls.localize('validations.expectedNumeric', "Value must be a number.")));
-            }
-            else {
-                errors.push(...( numericValidations.filter(validator => !validator.isValid(+value)).map(validator => validator.message)));
-            }
-        }
-        if (prop.type === 'string') {
-            if (prop.enum && !isStringArray(prop.enum)) {
-                errors.push(( nls.localize(
-                    'validations.stringIncorrectEnumOptions',
-                    'The enum options should be strings, but there is a non-string option. Please file an issue with the extension author.'
-                )));
-            }
-            else if (!isString(value)) {
-                errors.push(( nls.localize('validations.stringIncorrectType', 'Incorrect type. Expected "string".')));
-            }
-            else {
-                errors.push(...( stringValidations.filter(validator => !validator.isValid(value)).map(validator => validator.message)));
-            }
-        }
-        if (errors.length) {
-            return prop.errorMessage ? [prop.errorMessage, ...errors].join(' ') : errors.join(' ');
-        }
-        return '';
-    };
-}
-function getInvalidTypeError(value, type) {
-    if (typeof type === 'undefined') {
-        return;
-    }
-    const typeArr = Array.isArray(type) ? type : [type];
-    if (!( typeArr.some(_type => valueValidatesAsType(value, _type)))) {
-        return ( nls.localize(
-            'invalidTypeError',
-            "Setting has an invalid type, expected {0}. Fix in JSON.",
-            JSON.stringify(type)
-        ));
-    }
-    return;
-}
-function valueValidatesAsType(value, type) {
-    const valueType = typeof value;
-    if (type === 'boolean') {
-        return valueType === 'boolean';
-    }
-    else if (type === 'object') {
-        return value && !Array.isArray(value) && valueType === 'object';
-    }
-    else if (type === 'null') {
-        return value === null;
-    }
-    else if (type === 'array') {
-        return Array.isArray(value);
-    }
-    else if (type === 'string') {
-        return valueType === 'string';
-    }
-    else if (type === 'number' || type === 'integer') {
-        return valueType === 'number';
-    }
-    return true;
-}
-function getStringValidators(prop) {
-    const uriRegex = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
-    let patternRegex;
-    if (typeof prop.pattern === 'string') {
-        patternRegex = ( new RegExp(prop.pattern));
-    }
-    return [
-        {
-            enabled: prop.maxLength !== undefined,
-            isValid: ((value) => value.length <= prop.maxLength),
-            message: ( nls.localize(
-                'validations.maxLength',
-                "Value must be {0} or fewer characters long.",
-                prop.maxLength
-            ))
-        },
-        {
-            enabled: prop.minLength !== undefined,
-            isValid: ((value) => value.length >= prop.minLength),
-            message: ( nls.localize(
-                'validations.minLength',
-                "Value must be {0} or more characters long.",
-                prop.minLength
-            ))
-        },
-        {
-            enabled: patternRegex !== undefined,
-            isValid: ((value) => patternRegex.test(value)),
-            message: prop.patternErrorMessage || ( nls.localize('validations.regex', "Value must match regex `{0}`.", prop.pattern))
-        },
-        {
-            enabled: prop.format === 'color-hex',
-            isValid: ((value) => Color.Format.CSS.parseHex(value)),
-            message: ( nls.localize(
-                'validations.colorFormat',
-                "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."
-            ))
-        },
-        {
-            enabled: prop.format === 'uri' || prop.format === 'uri-reference',
-            isValid: ((value) => !!value.length),
-            message: ( nls.localize('validations.uriEmpty', "URI expected."))
-        },
-        {
-            enabled: prop.format === 'uri' || prop.format === 'uri-reference',
-            isValid: ((value) => uriRegex.test(value)),
-            message: ( nls.localize('validations.uriMissing', "URI is expected."))
-        },
-        {
-            enabled: prop.format === 'uri',
-            isValid: ((value) => {
-                const matches = value.match(uriRegex);
-                return !!(matches && matches[2]);
-            }),
-            message: ( nls.localize('validations.uriSchemeMissing', "URI with a scheme is expected."))
-        },
-        {
-            enabled: prop.enum !== undefined,
-            isValid: ((value) => {
-                return prop.enum.includes(value);
-            }),
-            message: ( nls.localize(
-                'validations.invalidStringEnumValue',
-                "Value is not accepted. Valid values: {0}.",
-                prop.enum ? ( prop.enum.map(key => `"${key}"`)).join(', ') : '[]'
-            ))
-        }
-    ].filter(validation => validation.enabled);
-}
-function getNumericValidators(prop) {
-    const type = Array.isArray(prop.type) ? prop.type : [prop.type];
-    const isNullable = canBeType(type, 'null');
-    const isIntegral = (canBeType(type, 'integer')) && (type.length === 1 || type.length === 2 && isNullable);
-    const isNumeric = canBeType(type, 'number', 'integer') && (type.length === 1 || type.length === 2 && isNullable);
-    if (!isNumeric) {
-        return [];
-    }
-    let exclusiveMax;
-    let exclusiveMin;
-    if (typeof prop.exclusiveMaximum === 'boolean') {
-        exclusiveMax = prop.exclusiveMaximum ? prop.maximum : undefined;
-    }
-    else {
-        exclusiveMax = prop.exclusiveMaximum;
-    }
-    if (typeof prop.exclusiveMinimum === 'boolean') {
-        exclusiveMin = prop.exclusiveMinimum ? prop.minimum : undefined;
-    }
-    else {
-        exclusiveMin = prop.exclusiveMinimum;
-    }
-    return [
-        {
-            enabled: exclusiveMax !== undefined && (prop.maximum === undefined || exclusiveMax <= prop.maximum),
-            isValid: ((value) => value < exclusiveMax),
-            message: ( nls.localize(
-                'validations.exclusiveMax',
-                "Value must be strictly less than {0}.",
-                exclusiveMax
-            ))
-        },
-        {
-            enabled: exclusiveMin !== undefined && (prop.minimum === undefined || exclusiveMin >= prop.minimum),
-            isValid: ((value) => value > exclusiveMin),
-            message: ( nls.localize(
-                'validations.exclusiveMin',
-                "Value must be strictly greater than {0}.",
-                exclusiveMin
-            ))
-        },
-        {
-            enabled: prop.maximum !== undefined && (exclusiveMax === undefined || exclusiveMax > prop.maximum),
-            isValid: ((value) => value <= prop.maximum),
-            message: ( nls.localize(
-                'validations.max',
-                "Value must be less than or equal to {0}.",
-                prop.maximum
-            ))
-        },
-        {
-            enabled: prop.minimum !== undefined && (exclusiveMin === undefined || exclusiveMin < prop.minimum),
-            isValid: ((value) => value >= prop.minimum),
-            message: ( nls.localize(
-                'validations.min',
-                "Value must be greater than or equal to {0}.",
-                prop.minimum
-            ))
-        },
-        {
-            enabled: prop.multipleOf !== undefined,
-            isValid: ((value) => value % prop.multipleOf === 0),
-            message: ( nls.localize(
-                'validations.multipleOf',
-                "Value must be a multiple of {0}.",
-                prop.multipleOf
-            ))
-        },
-        {
-            enabled: isIntegral,
-            isValid: ((value) => value % 1 === 0),
-            message: ( nls.localize('validations.expectedInteger', "Value must be an integer."))
-        },
-    ].filter(validation => validation.enabled);
-}
-function getArrayValidator(prop) {
-    if (prop.type === 'array' && prop.items && !Array.isArray(prop.items)) {
-        const propItems = prop.items;
-        if (propItems && !Array.isArray(propItems.type)) {
-            const withQuotes = (s) => `'` + s + `'`;
-            return value => {
-                if (!value) {
-                    return null;
-                }
-                let message = '';
-                if (!Array.isArray(value)) {
-                    message += ( nls.localize('validations.arrayIncorrectType', 'Incorrect type. Expected an array.'));
-                    message += '\n';
-                    return message;
-                }
-                const arrayValue = value;
-                if (prop.uniqueItems) {
-                    if (( new Set(arrayValue)).size < arrayValue.length) {
-                        message += ( nls.localize('validations.stringArrayUniqueItems', 'Array has duplicate items'));
-                        message += '\n';
-                    }
-                }
-                if (prop.minItems && arrayValue.length < prop.minItems) {
-                    message += ( nls.localize(
-                        'validations.stringArrayMinItem',
-                        'Array must have at least {0} items',
-                        prop.minItems
-                    ));
-                    message += '\n';
-                }
-                if (prop.maxItems && arrayValue.length > prop.maxItems) {
-                    message += ( nls.localize(
-                        'validations.stringArrayMaxItem',
-                        'Array must have at most {0} items',
-                        prop.maxItems
-                    ));
-                    message += '\n';
-                }
-                if (propItems.type === 'string') {
-                    if (!isStringArray(arrayValue)) {
-                        message += ( nls.localize(
-                            'validations.stringArrayIncorrectType',
-                            'Incorrect type. Expected a string array.'
-                        ));
-                        message += '\n';
-                        return message;
-                    }
-                    if (typeof propItems.pattern === 'string') {
-                        const patternRegex = ( new RegExp(propItems.pattern));
-                        arrayValue.forEach(v => {
-                            if (!patternRegex.test(v)) {
-                                message +=
-                                    propItems.patternErrorMessage ||
-                                        ( nls.localize(
-                                            'validations.stringArrayItemPattern',
-                                            'Value {0} must match regex {1}.',
-                                            withQuotes(v),
-                                            withQuotes(propItems.pattern)
-                                        ));
-                            }
-                        });
-                    }
-                    const propItemsEnum = propItems.enum;
-                    if (propItemsEnum) {
-                        arrayValue.forEach(v => {
-                            if (propItemsEnum.indexOf(v) === -1) {
-                                message += ( nls.localize(
-                                    'validations.stringArrayItemEnum',
-                                    'Value {0} is not one of {1}',
-                                    withQuotes(v),
-                                    '[' + ( propItemsEnum.map(withQuotes)).join(', ') + ']'
-                                ));
-                                message += '\n';
-                            }
-                        });
-                    }
-                }
-                else if (propItems.type === 'integer' || propItems.type === 'number') {
-                    arrayValue.forEach(v => {
-                        const errorMessage = getErrorsForSchema(propItems, v);
-                        if (errorMessage) {
-                            message += `${v}: ${errorMessage}\n`;
-                        }
-                    });
-                }
-                return message;
-            };
-        }
-    }
-    return null;
-}
-function getObjectValidator(prop) {
-    if (prop.type === 'object') {
-        const { properties, patternProperties, additionalProperties } = prop;
-        return value => {
-            if (!value) {
-                return null;
-            }
-            const errors = [];
-            if (!isObject(value)) {
-                errors.push(( nls.localize('validations.objectIncorrectType', 'Incorrect type. Expected an object.')));
-            }
-            else {
-                ( Object.keys(value)).forEach((key) => {
-                    const data = value[key];
-                    if (properties && key in properties) {
-                        const errorMessage = getErrorsForSchema(properties[key], data);
-                        if (errorMessage) {
-                            errors.push(`${key}: ${errorMessage}\n`);
-                        }
-                        return;
-                    }
-                    if (patternProperties) {
-                        for (const pattern in patternProperties) {
-                            if (RegExp(pattern).test(key)) {
-                                const errorMessage = getErrorsForSchema(patternProperties[pattern], data);
-                                if (errorMessage) {
-                                    errors.push(`${key}: ${errorMessage}\n`);
-                                }
-                                return;
-                            }
-                        }
-                    }
-                    if (additionalProperties === false) {
-                        errors.push(( nls.localize('validations.objectPattern', 'Property {0} is not allowed.\n', key)));
-                    }
-                    else if (typeof additionalProperties === 'object') {
-                        const errorMessage = getErrorsForSchema(additionalProperties, data);
-                        if (errorMessage) {
-                            errors.push(`${key}: ${errorMessage}\n`);
-                        }
-                    }
-                });
-            }
-            if (errors.length) {
-                return prop.errorMessage ? [prop.errorMessage, ...errors].join(' ') : errors.join(' ');
-            }
-            return '';
-        };
-    }
-    return null;
-}
-function getErrorsForSchema(propertySchema, data) {
-    const validator = createValidator(propertySchema);
-    const errorMessage = validator(data);
-    return errorMessage;
-}
-export { createValidator, getInvalidTypeError };

package/vscode/src/vs/workbench/services/remote/browser/remoteAgentService.js

@@ -1,71 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
-import { IRemoteAgentService } from '../common/remoteAgentService.js';
-import { RemoteAuthorityResolverError, IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
-import { AbstractRemoteAgentService } from '../common/abstractRemoteAgentService.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { ISignService } from '../../../../platform/sign/common/sign.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from '../../../common/contributions.js';
-import { IHostService } from '../../host/browser/host.js';
-import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
-import { IRemoteSocketFactoryService } from '../../../../platform/remote/common/remoteSocketFactoryService.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-let RemoteAgentService = class RemoteAgentService extends AbstractRemoteAgentService {
-    constructor(remoteSocketFactoryService, userDataProfileService, environmentService, productService, remoteAuthorityResolverService, signService, logService) {
-        super(remoteSocketFactoryService, userDataProfileService, environmentService, productService, remoteAuthorityResolverService, signService, logService);
-    }
-};
-RemoteAgentService = ( __decorate([
-    ( __param(0, IRemoteSocketFactoryService)),
-    ( __param(1, IUserDataProfileService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IProductService)),
-    ( __param(4, IRemoteAuthorityResolverService)),
-    ( __param(5, ISignService)),
-    ( __param(6, ILogService))
-], RemoteAgentService));
-let RemoteConnectionFailureNotificationContribution = class RemoteConnectionFailureNotificationContribution {
-    constructor(remoteAgentService, _dialogService, _hostService) {
-        this._dialogService = _dialogService;
-        this._hostService = _hostService;
-        remoteAgentService.getRawEnvironment()
-            .then(undefined, (err) => {
-            if (!RemoteAuthorityResolverError.isHandled(err)) {
-                this._presentConnectionError(err);
-            }
-        });
-    }
-    async _presentConnectionError(err) {
-        await this._dialogService.prompt({
-            type: Severity.Error,
-            message: ( nls.localize(
-                'connectionError',
-                "An unexpected error occurred that requires a reload of this page."
-            )),
-            detail: ( nls.localize(
-                'connectionErrorDetail',
-                "The workbench failed to connect to the server (Error: {0})",
-                err ? err.message : ''
-            )),
-            buttons: [
-                {
-                    label: ( nls.localize({ key: 'reload', comment: ['&& denotes a mnemonic'] }, "&&Reload")),
-                    run: () => this._hostService.reload()
-                }
-            ]
-        });
-    }
-};
-RemoteConnectionFailureNotificationContribution = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, IDialogService)),
-    ( __param(2, IHostService))
-], RemoteConnectionFailureNotificationContribution));
-const workbenchRegistry = ( Registry.as(Extensions.Workbench));
-workbenchRegistry.registerWorkbenchContribution(RemoteConnectionFailureNotificationContribution, 2 );
-export { RemoteAgentService };

package/vscode/src/vs/workbench/services/remote/common/abstractRemoteAgentService.js

@@ -1,177 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { getDelayedChannel } from '../../../../base/parts/ipc/common/ipc.js';
-import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
-import { connectRemoteAgentManagement } from '../../../../platform/remote/common/remoteAgentConnection.js';
-import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
-import { RemoteExtensionEnvironmentChannelClient } from './remoteAgentEnvironmentChannel.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { ISignService } from '../../../../platform/sign/common/sign.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
-import { IRemoteSocketFactoryService } from '../../../../platform/remote/common/remoteSocketFactoryService.js';
-let AbstractRemoteAgentService = class AbstractRemoteAgentService extends Disposable {
-    constructor(remoteSocketFactoryService, userDataProfileService, _environmentService, productService, _remoteAuthorityResolverService, signService, logService) {
-        super();
-        this.remoteSocketFactoryService = remoteSocketFactoryService;
-        this.userDataProfileService = userDataProfileService;
-        this._environmentService = _environmentService;
-        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
-        if (this._environmentService.remoteAuthority) {
-            this._connection = this._register(( new RemoteAgentConnection(
-                this._environmentService.remoteAuthority,
-                productService.commit,
-                productService.quality,
-                this.remoteSocketFactoryService,
-                this._remoteAuthorityResolverService,
-                signService,
-                logService
-            )));
-        }
-        else {
-            this._connection = null;
-        }
-        this._environment = null;
-    }
-    getConnection() {
-        return this._connection;
-    }
-    getEnvironment() {
-        return this.getRawEnvironment().then(undefined, () => null);
-    }
-    getRawEnvironment() {
-        if (!this._environment) {
-            this._environment = this._withChannel(async (channel, connection) => {
-                const env = await RemoteExtensionEnvironmentChannelClient.getEnvironmentData(channel, connection.remoteAuthority, this.userDataProfileService.currentProfile.isDefault ? undefined : this.userDataProfileService.currentProfile.id);
-                this._remoteAuthorityResolverService._setAuthorityConnectionToken(connection.remoteAuthority, env.connectionToken);
-                return env;
-            }, null);
-        }
-        return this._environment;
-    }
-    getExtensionHostExitInfo(reconnectionToken) {
-        return this._withChannel((channel, connection) => RemoteExtensionEnvironmentChannelClient.getExtensionHostExitInfo(channel, connection.remoteAuthority, reconnectionToken), null);
-    }
-    getDiagnosticInfo(options) {
-        return this._withChannel(channel => RemoteExtensionEnvironmentChannelClient.getDiagnosticInfo(channel, options), undefined);
-    }
-    updateTelemetryLevel(telemetryLevel) {
-        return this._withTelemetryChannel(channel => RemoteExtensionEnvironmentChannelClient.updateTelemetryLevel(channel, telemetryLevel), undefined);
-    }
-    logTelemetry(eventName, data) {
-        return this._withTelemetryChannel(channel => RemoteExtensionEnvironmentChannelClient.logTelemetry(channel, eventName, data), undefined);
-    }
-    flushTelemetry() {
-        return this._withTelemetryChannel(channel => RemoteExtensionEnvironmentChannelClient.flushTelemetry(channel), undefined);
-    }
-    getRoundTripTime() {
-        return this._withTelemetryChannel(async (channel) => {
-            const start = Date.now();
-            await RemoteExtensionEnvironmentChannelClient.ping(channel);
-            return Date.now() - start;
-        }, undefined);
-    }
-    _withChannel(callback, fallback) {
-        const connection = this.getConnection();
-        if (!connection) {
-            return Promise.resolve(fallback);
-        }
-        return connection.withChannel('remoteextensionsenvironment', (channel) => callback(channel, connection));
-    }
-    _withTelemetryChannel(callback, fallback) {
-        const connection = this.getConnection();
-        if (!connection) {
-            return Promise.resolve(fallback);
-        }
-        return connection.withChannel('telemetry', (channel) => callback(channel, connection));
-    }
-};
-AbstractRemoteAgentService = ( __decorate([
-    ( __param(0, IRemoteSocketFactoryService)),
-    ( __param(1, IUserDataProfileService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IProductService)),
-    ( __param(4, IRemoteAuthorityResolverService)),
-    ( __param(5, ISignService)),
-    ( __param(6, ILogService))
-], AbstractRemoteAgentService));
-class RemoteAgentConnection extends Disposable {
-    constructor(remoteAuthority, _commit, _quality, _remoteSocketFactoryService, _remoteAuthorityResolverService, _signService, _logService) {
-        super();
-        this._commit = _commit;
-        this._quality = _quality;
-        this._remoteSocketFactoryService = _remoteSocketFactoryService;
-        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
-        this._signService = _signService;
-        this._logService = _logService;
-        this._onReconnecting = this._register(( new Emitter()));
-        this.onReconnecting = this._onReconnecting.event;
-        this._onDidStateChange = this._register(( new Emitter()));
-        this.onDidStateChange = this._onDidStateChange.event;
-        this.remoteAuthority = remoteAuthority;
-        this._connection = null;
-    }
-    getChannel(channelName) {
-        return getDelayedChannel(this._getOrCreateConnection().then(c => c.getChannel(channelName)));
-    }
-    withChannel(channelName, callback) {
-        const channel = this.getChannel(channelName);
-        const result = callback(channel);
-        return result;
-    }
-    registerChannel(channelName, channel) {
-        this._getOrCreateConnection().then(client => client.registerChannel(channelName, channel));
-    }
-    async getInitialConnectionTimeMs() {
-        try {
-            await this._getOrCreateConnection();
-        }
-        catch {
-        }
-        return this._initialConnectionMs;
-    }
-    _getOrCreateConnection() {
-        if (!this._connection) {
-            this._connection = this._createConnection();
-        }
-        return this._connection;
-    }
-    async _createConnection() {
-        let firstCall = true;
-        const options = {
-            commit: this._commit,
-            quality: this._quality,
-            addressProvider: {
-                getAddress: async () => {
-                    if (firstCall) {
-                        firstCall = false;
-                    }
-                    else {
-                        this._onReconnecting.fire(undefined);
-                    }
-                    const { authority } = await this._remoteAuthorityResolverService.resolveAuthority(this.remoteAuthority);
-                    return { connectTo: authority.connectTo, connectionToken: authority.connectionToken };
-                }
-            },
-            remoteSocketFactoryService: this._remoteSocketFactoryService,
-            signService: this._signService,
-            logService: this._logService,
-            ipcLogger: null
-        };
-        let connection;
-        const start = Date.now();
-        try {
-            connection = this._register(await connectRemoteAgentManagement(options, this.remoteAuthority, `renderer`));
-        }
-        finally {
-            this._initialConnectionMs = Date.now() - start;
-        }
-        connection.protocol.onDidDispose(() => {
-            connection.dispose();
-        });
-        this._register(connection.onDidStateChange(e => this._onDidStateChange.fire(e)));
-        return connection.client;
-    }
-}
-export { AbstractRemoteAgentService };