@codingame/monaco-vscode-api 2.2.2 → 3.1.0

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

@@ -0,0 +1,477 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { Color } from '../../../../base/common/color.js';
+import { isStringArray, isUndefinedOrNull, isString, isObject } from '../../../../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(( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.booleanIncorrectType',
+                'Incorrect type. Expected "boolean".'
+            )));
+        }
+        if (isNumeric) {
+            if (isNullOrEmpty(value) || typeof value === 'boolean' || Array.isArray(value) || isNaN(+value)) {
+                errors.push(( localizeWithPath(
+                    'vs/workbench/services/preferences/common/preferencesValidation',
+                    '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(( localizeWithPath(
+                    'vs/workbench/services/preferences/common/preferencesValidation',
+                    '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(( localizeWithPath(
+                    'vs/workbench/services/preferences/common/preferencesValidation',
+                    '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 ( localizeWithPath(
+            'vs/workbench/services/preferences/common/preferencesValidation',
+            '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 toRegExp(pattern) {
+    try {
+        return ( new RegExp(pattern, 'u'));
+    }
+    catch (e) {
+        try {
+            return ( new RegExp(pattern));
+        }
+        catch (e) {
+            console.error(( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'regexParsingError',
+                "Error parsing the following regex both with and without the u flag:"
+            )), pattern);
+            return /.*/;
+        }
+    }
+}
+function getStringValidators(prop) {
+    const uriRegex = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+    let patternRegex;
+    if (typeof prop.pattern === 'string') {
+        patternRegex = toRegExp(prop.pattern);
+    }
+    return [
+        {
+            enabled: prop.maxLength !== undefined,
+            isValid: ((value) => value.length <= prop.maxLength),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.maxLength',
+                "Value must be {0} or fewer characters long.",
+                prop.maxLength
+            ))
+        },
+        {
+            enabled: prop.minLength !== undefined,
+            isValid: ((value) => value.length >= prop.minLength),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.minLength',
+                "Value must be {0} or more characters long.",
+                prop.minLength
+            ))
+        },
+        {
+            enabled: patternRegex !== undefined,
+            isValid: ((value) => patternRegex.test(value)),
+            message: prop.patternErrorMessage || ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.regex',
+                "Value must match regex `{0}`.",
+                prop.pattern
+            ))
+        },
+        {
+            enabled: prop.format === 'color-hex',
+            isValid: ((value) => Color.Format.CSS.parseHex(value)),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.colorFormat',
+                "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."
+            ))
+        },
+        {
+            enabled: prop.format === 'uri' || prop.format === 'uri-reference',
+            isValid: ((value) => !!value.length),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.uriEmpty',
+                "URI expected."
+            ))
+        },
+        {
+            enabled: prop.format === 'uri' || prop.format === 'uri-reference',
+            isValid: ((value) => uriRegex.test(value)),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.uriMissing',
+                "URI is expected."
+            ))
+        },
+        {
+            enabled: prop.format === 'uri',
+            isValid: ((value) => {
+                const matches = value.match(uriRegex);
+                return !!(matches && matches[2]);
+            }),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.uriSchemeMissing',
+                "URI with a scheme is expected."
+            ))
+        },
+        {
+            enabled: prop.enum !== undefined,
+            isValid: ((value) => {
+                return prop.enum.includes(value);
+            }),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                '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: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.exclusiveMax',
+                "Value must be strictly less than {0}.",
+                exclusiveMax
+            ))
+        },
+        {
+            enabled: exclusiveMin !== undefined && (prop.minimum === undefined || exclusiveMin >= prop.minimum),
+            isValid: ((value) => value > exclusiveMin),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                '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: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                '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: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.min',
+                "Value must be greater than or equal to {0}.",
+                prop.minimum
+            ))
+        },
+        {
+            enabled: prop.multipleOf !== undefined,
+            isValid: ((value) => value % prop.multipleOf === 0),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                'validations.multipleOf',
+                "Value must be a multiple of {0}.",
+                prop.multipleOf
+            ))
+        },
+        {
+            enabled: isIntegral,
+            isValid: ((value) => value % 1 === 0),
+            message: ( localizeWithPath(
+                'vs/workbench/services/preferences/common/preferencesValidation',
+                '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 += ( localizeWithPath(
+                        'vs/workbench/services/preferences/common/preferencesValidation',
+                        '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 += ( localizeWithPath(
+                            'vs/workbench/services/preferences/common/preferencesValidation',
+                            'validations.stringArrayUniqueItems',
+                            'Array has duplicate items'
+                        ));
+                        message += '\n';
+                    }
+                }
+                if (prop.minItems && arrayValue.length < prop.minItems) {
+                    message += ( localizeWithPath(
+                        'vs/workbench/services/preferences/common/preferencesValidation',
+                        'validations.stringArrayMinItem',
+                        'Array must have at least {0} items',
+                        prop.minItems
+                    ));
+                    message += '\n';
+                }
+                if (prop.maxItems && arrayValue.length > prop.maxItems) {
+                    message += ( localizeWithPath(
+                        'vs/workbench/services/preferences/common/preferencesValidation',
+                        'validations.stringArrayMaxItem',
+                        'Array must have at most {0} items',
+                        prop.maxItems
+                    ));
+                    message += '\n';
+                }
+                if (propItems.type === 'string') {
+                    if (!isStringArray(arrayValue)) {
+                        message += ( localizeWithPath(
+                            'vs/workbench/services/preferences/common/preferencesValidation',
+                            'validations.stringArrayIncorrectType',
+                            'Incorrect type. Expected a string array.'
+                        ));
+                        message += '\n';
+                        return message;
+                    }
+                    if (typeof propItems.pattern === 'string') {
+                        const patternRegex = toRegExp(propItems.pattern);
+                        arrayValue.forEach(v => {
+                            if (!patternRegex.test(v)) {
+                                message +=
+                                    propItems.patternErrorMessage ||
+                                        ( localizeWithPath(
+                                            'vs/workbench/services/preferences/common/preferencesValidation',
+                                            '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 += ( localizeWithPath(
+                                    'vs/workbench/services/preferences/common/preferencesValidation',
+                                    '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(( localizeWithPath(
+                    'vs/workbench/services/preferences/common/preferencesValidation',
+                    '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(( localizeWithPath(
+                            'vs/workbench/services/preferences/common/preferencesValidation',
+                            '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/common/remoteExplorerService.js

@@ -44,7 +44,7 @@ const getStartedWalkthrough = {
         },
     }
 };
-const remoteHelpExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const remoteHelpExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'remoteHelp',
     jsonSchema: {
         description: ( localizeWithPath(
@@ -105,7 +105,7 @@ const remoteHelpExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             }
         }
     }
-}));
+});
 let RemoteExplorerService = class RemoteExplorerService {
     constructor(storageService, tunnelService, instantiationService) {
         this.storageService = storageService;

package/vscode/src/vs/workbench/services/remote/common/tunnelModel.d.ts

@@ -148,9 +148,12 @@ declare class TunnelModel extends Disposable {
     private checkExtensionActivationEvents;
     private onTunnelClosed;
     private makeLocalUri;
-    private getStorageKey;
+    private addStorageKeyPostfix;
+    private getTunnelRestoreStorageKey;
+    private getRestoreExpirationStorageKey;
     private getTunnelRestoreValue;
     restoreForwarded(): Promise<void>;
+    private cleanupExpiredTunnelsForRestore;
     private storeForwarded;
     private mismatchCooldown;
     private showPortMismatchModalIfNeeded;

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

@@ -22,6 +22,8 @@ import { RawContextKey, IContextKeyService } from '../../../../platform/contextk
 import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 const MISMATCH_LOCAL_PORT_COOLDOWN = 10 * 1000;
 const TUNNELS_TO_RESTORE = 'remote.tunnels.toRestore';
+const TUNNELS_TO_RESTORE_EXPIRATION = 'remote.tunnels.toRestoreExpiration';
+const RESTORE_EXPIRATION_TIME = 1000 * 60 * 60 * 24 * 14;
 const ACTIVATION_EVENT = 'onTunnel';
 const forwardedPortsViewEnabled = ( new RawContextKey('forwardedPortsViewEnabled', false, ( localizeWithPath(
     'vs/workbench/services/remote/common/tunnelModel',
@@ -439,14 +441,20 @@ let TunnelModel = class TunnelModel extends Disposable {
         const protocol = attributes?.protocol ?? 'http';
         return ( URI.parse(`${protocol}://${localAddress}`));
     }
-    async getStorageKey() {
+    async addStorageKeyPostfix(prefix) {
         const workspace = this.workspaceContextService.getWorkspace();
         const workspaceHash = workspace.configuration ? hash(workspace.configuration.path) : (workspace.folders.length > 0 ? hash(workspace.folders[0].uri.path) : undefined);
         if (workspaceHash === undefined) {
             this.logService.debug('Could not get workspace hash for forwarded ports storage key.');
             return undefined;
         }
-        return `${TUNNELS_TO_RESTORE}.${this.environmentService.remoteAuthority}.${workspaceHash}`;
+        return `${prefix}.${this.environmentService.remoteAuthority}.${workspaceHash}`;
+    }
+    async getTunnelRestoreStorageKey() {
+        return this.addStorageKeyPostfix(TUNNELS_TO_RESTORE);
+    }
+    async getRestoreExpirationStorageKey() {
+        return this.addStorageKeyPostfix(TUNNELS_TO_RESTORE_EXPIRATION);
     }
     async getTunnelRestoreValue() {
         const deprecatedValue = this.storageService.get(TUNNELS_TO_RESTORE, 1 );
@@ -455,13 +463,14 @@ let TunnelModel = class TunnelModel extends Disposable {
             await this.storeForwarded();
             return deprecatedValue;
         }
-        const storageKey = await this.getStorageKey();
+        const storageKey = await this.getTunnelRestoreStorageKey();
         if (!storageKey) {
             return undefined;
         }
         return this.storageService.get(storageKey, 0 );
     }
     async restoreForwarded() {
+        this.cleanupExpiredTunnelsForRestore();
         if (this.configurationService.getValue('remote.restoreForwardedPorts')) {
             const tunnelRestoreValue = await this.tunnelRestoreValue;
             if (tunnelRestoreValue && (tunnelRestoreValue !== this.knownPortsRestoreValue)) {
@@ -474,7 +483,6 @@ let TunnelModel = class TunnelModel extends Disposable {
                             remote: { host: tunnel.remoteHost, port: tunnel.remotePort },
                             local: tunnel.localPort,
                             name: tunnel.name,
-                            privacy: tunnel.privacy,
                             elevateIfNeeded: true,
                             source: tunnel.source
                         });
@@ -488,7 +496,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         this.restoreComplete = true;
         this.onRestoreComplete.fire();
         if (!this.restoreListener) {
-            const key = await this.getStorageKey();
+            const key = await this.getTunnelRestoreStorageKey();
             this.restoreListener = this._register(( new DisposableStore()));
             this.restoreListener.add(this.storageService.onDidChangeValue(0 , undefined, this.restoreListener)(async (e) => {
                 if (e.key === key) {
@@ -498,16 +506,48 @@ let TunnelModel = class TunnelModel extends Disposable {
             }));
         }
     }
+    cleanupExpiredTunnelsForRestore() {
+        const keys = ( this.storageService.keys(0, 0 )).filter(key => key.startsWith(TUNNELS_TO_RESTORE_EXPIRATION));
+        for (const key of keys) {
+            const expiration = this.storageService.getNumber(key, 0 );
+            if (expiration && expiration < Date.now()) {
+                this.tunnelRestoreValue = Promise.resolve(undefined);
+                const storageKey = key.replace(TUNNELS_TO_RESTORE_EXPIRATION, TUNNELS_TO_RESTORE);
+                this.storageService.remove(key, 0 );
+                this.storageService.remove(storageKey, 0 );
+            }
+        }
+    }
     async storeForwarded() {
         if (this.configurationService.getValue('remote.restoreForwardedPorts')) {
-            const valueToStore = JSON.stringify(Array.from(( this.forwarded.values())));
-            if (valueToStore !== this.knownPortsRestoreValue) {
-                this.knownPortsRestoreValue = valueToStore;
-                const key = await this.getStorageKey();
-                if (key) {
-                    this.storageService.store(key, this.knownPortsRestoreValue, 0 , 0 );
-                }
+            const forwarded = Array.from(( this.forwarded.values()));
+            const restorableTunnels = ( forwarded.map(tunnel => {
+                return {
+                    remoteHost: tunnel.remoteHost,
+                    remotePort: tunnel.remotePort,
+                    localPort: tunnel.localPort,
+                    name: tunnel.name,
+                    localAddress: tunnel.localAddress,
+                    localUri: tunnel.localUri,
+                    protocol: tunnel.protocol,
+                    source: tunnel.source,
+                };
+            }));
+            let valueToStore;
+            if (forwarded.length > 0) {
+                valueToStore = JSON.stringify(restorableTunnels);
+            }
+            const key = await this.getTunnelRestoreStorageKey();
+            const expirationKey = await this.getRestoreExpirationStorageKey();
+            if (!valueToStore && key && expirationKey) {
+                this.storageService.remove(key, 0 );
+                this.storageService.remove(expirationKey, 0 );
+            }
+            else if ((valueToStore !== this.knownPortsRestoreValue) && key && expirationKey) {
+                this.storageService.store(key, valueToStore, 0 , 0 );
+                this.storageService.store(expirationKey, Date.now() + RESTORE_EXPIRATION_TIME, 0 , 0 );
             }
+            this.knownPortsRestoreValue = valueToStore;
         }
     }
     async showPortMismatchModalIfNeeded(tunnel, expectedLocal, attributes) {
@@ -602,7 +642,7 @@ let TunnelModel = class TunnelModel extends Disposable {
             if (updateProps) {
                 tunnelProperties.name = updateProps.name ?? tunnelProperties.name;
                 tunnelProperties.local = (('local' in updateProps) ? updateProps.local : (('localPort' in updateProps) ? updateProps.localPort : undefined)) ?? tunnelProperties.local;
-                tunnelProperties.privacy = updateProps.privacy ?? tunnelProperties.privacy;
+                tunnelProperties.privacy = tunnelProperties.privacy;
             }
         }
         return tunnelProperties;

package/vscode/src/vs/workbench/services/search/common/queryBuilder.js

@@ -98,6 +98,7 @@ let QueryBuilder = class QueryBuilder {
             exists: options.exists,
             sortByScore: options.sortByScore,
             cacheKey: options.cacheKey,
+            shouldGlobMatchFilePattern: options.shouldGlobSearch
         };
     }
     handleIncludeExclude(pattern, expandPatterns) {

package/vscode/src/vs/workbench/services/textMate/common/TMGrammars.js

@@ -1,7 +1,7 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 import { languagesExtPoint } from '../../language/common/languageService.js';
-const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'grammars',
     deps: [languagesExtPoint],
     jsonSchema: {
@@ -98,5 +98,5 @@ const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             required: ['scopeName', 'path']
         }
     }
-}));
+});
 export { grammarsExtPoint };

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModel.js

@@ -512,7 +512,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
                     if (!saveCancellation.token.isCancellationRequested) {
                         this.ignoreSaveFromSaveParticipants = true;
                         try {
-                            await this.textFileService.files.runSaveParticipants(this, { reason: options.reason ?? 1  }, saveCancellation.token);
+                            await this.textFileService.files.runSaveParticipants(this, { reason: options.reason ?? 1 , savedFrom: options.from }, saveCancellation.token);
                         }
                         finally {
                             this.ignoreSaveFromSaveParticipants = false;