@codingame/monaco-vscode-api 4.5.0 → 4.5.2

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

@@ -19,6 +19,7 @@ import { IWorkspaceContextService } from '../../../../platform/workspace/common/
 import { IEditorGroupsService } from '../../editor/common/editorGroupsService.service.js';
 import { IPathService } from '../../path/common/pathService.service.js';
 import { pathIncludedInQuery, getExcludes } from './search.js';
+const _moduleId = "vs/workbench/services/search/common/queryBuilder";
 let QueryBuilder = class QueryBuilder {
     constructor(configurationService, workspaceContextService, editorGroupsService, logService, pathService) {
         this.configurationService = configurationService;
@@ -30,10 +31,10 @@ let QueryBuilder = class QueryBuilder {
     text(contentPattern, folderResources, options = {}) {
         contentPattern = this.getContentPattern(contentPattern, options);
         const searchConfig = this.configurationService.getValue();
-        const fallbackToPCRE = folderResources && ( folderResources.some(folder => {
+        const fallbackToPCRE = folderResources && ( (folderResources.some(folder => {
             const folderConfig = this.configurationService.getValue({ resource: folder });
             return !folderConfig.search.useRipgrep;
-        }));
+        })));
         const commonQuery = this.commonQuery(folderResources?.map(toWorkspaceFolder), options);
         return {
             ...commonQuery,
@@ -106,7 +107,7 @@ let QueryBuilder = class QueryBuilder {
         if (!pattern) {
             return {};
         }
-        pattern = Array.isArray(pattern) ? ( pattern.map(normalizeSlashes)) : normalizeSlashes(pattern);
+        pattern = Array.isArray(pattern) ? ( (pattern.map(normalizeSlashes))) : normalizeSlashes(pattern);
         return expandPatterns
             ? this.parseSearchPaths(pattern)
             : { pattern: patternListToIExpression(...(Array.isArray(pattern) ? pattern : [pattern])) };
@@ -116,12 +117,12 @@ let QueryBuilder = class QueryBuilder {
         const excludeSearchPathsInfo = this.handleIncludeExclude(options.excludePattern, options.expandPatterns);
         const includeFolderName = folderResources.length > 1;
         const folderQueries = (includeSearchPathsInfo.searchPaths && includeSearchPathsInfo.searchPaths.length ?
-            ( includeSearchPathsInfo.searchPaths.map(
-                searchPath => this.getFolderQueryForSearchPath(searchPath, options, excludeSearchPathsInfo)
-            )) :
-            ( folderResources.map(
-                folder => this.getFolderQueryForRoot(folder, options, excludeSearchPathsInfo, includeFolderName)
-            )))
+            ( (includeSearchPathsInfo.searchPaths.map(
+            searchPath => this.getFolderQueryForSearchPath(searchPath, options, excludeSearchPathsInfo)
+        ))) :
+            ( (folderResources.map(
+            folder => this.getFolderQueryForRoot(folder, options, excludeSearchPathsInfo, includeFolderName)
+        ))))
             .filter(query => !!query);
         const queryProps = {
             _reason: options._reason,
@@ -134,7 +135,7 @@ let QueryBuilder = class QueryBuilder {
             maxResults: options.maxResults
         };
         if (options.onlyOpenEditors) {
-            const openEditors = coalesce(flatten(( this.editorGroupsService.groups.map(group => ( group.editors.map(editor => editor.resource))))));
+            const openEditors = coalesce(flatten(( (this.editorGroupsService.groups.map(group => ( (group.editors.map(editor => editor.resource))))))));
             this.logService.trace('QueryBuilder#commonQuery - openEditor URIs', JSON.stringify(openEditors));
             const openEditorsInQuery = openEditors.filter(editor => pathIncludedInQuery(queryProps, editor.fsPath));
             const openEditorsQueryProps = this.commonQueryFromFileList(openEditorsInQuery);
@@ -147,7 +148,7 @@ let QueryBuilder = class QueryBuilder {
     }
     commonQueryFromFileList(files) {
         const folderQueries = [];
-        const foldersToSearch = ( new ResourceMap());
+        const foldersToSearch = ( (new ResourceMap()));
         const includePattern = {};
         let hasIncludedFile = false;
         files.forEach(file => {
@@ -211,24 +212,24 @@ let QueryBuilder = class QueryBuilder {
             return isAbsolute(segment) || /^\.\.?([\/\\]|$)/.test(segment);
         };
         const patterns = Array.isArray(pattern) ? pattern : splitGlobPattern(pattern);
-        const segments = ( patterns
+        const segments = ( (patterns
             .map(segment => {
             const userHome = this.pathService.resolvedUserHome;
             if (userHome) {
                 return untildify(segment, userHome.scheme === Schemas.file ? userHome.fsPath : userHome.path);
             }
             return segment;
-        }));
+        })));
         const groups = groupBy(segments, segment => isSearchPath(segment) ? 'searchPaths' : 'exprSegments');
-        const expandedExprSegments = ( ( ( (groups.exprSegments || [])
-            .map(s => rtrim(s, '/')))
-            .map(s => rtrim(s, '\\')))
+        const expandedExprSegments = ( (( (( ((groups.exprSegments || [])
+            .map(s => rtrim(s, '/'))))
+            .map(s => rtrim(s, '\\'))))
             .map(p => {
             if (p[0] === '.') {
                 p = '*' + p;
             }
             return expandGlobalGlob(p);
-        }));
+        })));
         const result = {};
         const searchPaths = this.expandSearchPathPatterns(groups.searchPaths || []);
         if (searchPaths && searchPaths.length) {
@@ -258,9 +259,9 @@ let QueryBuilder = class QueryBuilder {
             const oneExpanded = this.expandOneSearchPath(pathPortion);
             return oneExpanded.flatMap(oneExpandedResult => this.resolveOneSearchPathPattern(oneExpandedResult, globPortion));
         });
-        const searchPathPatternMap = ( new Map());
+        const searchPathPatternMap = ( (new Map()));
         expandedSearchPaths.forEach(oneSearchPathPattern => {
-            const key = ( oneSearchPathPattern.searchPath.toString());
+            const key = ( (oneSearchPathPattern.searchPath.toString()));
             const existing = searchPathPatternMap.get(key);
             if (existing) {
                 if (oneSearchPathPattern.pattern) {
@@ -275,7 +276,7 @@ let QueryBuilder = class QueryBuilder {
                 });
             }
         });
-        return Array.from(( searchPathPatternMap.values()));
+        return Array.from(( (searchPathPatternMap.values())));
     }
     expandOneSearchPath(searchPath) {
         if (isAbsolute(searchPath)) {
@@ -310,32 +311,34 @@ let QueryBuilder = class QueryBuilder {
         else {
             const searchPathWithoutDotSlash = searchPath.replace(/^\.[\/\\]/, '');
             const folders = this.workspaceContextService.getWorkspace().folders;
-            const folderMatches = ( folders.map(folder => {
-                const match = searchPathWithoutDotSlash.match(( new RegExp(`^${escapeRegExpCharacters(folder.name)}(?:/(.*)|$)`)));
+            const folderMatches = ( (folders.map(folder => {
+                const match = searchPathWithoutDotSlash.match(( (new RegExp(`^${escapeRegExpCharacters(folder.name)}(?:/(.*)|$)`))));
                 return match ? {
                     match,
                     folder
                 } : null;
-            })).filter(isDefined);
+            }))).filter(isDefined);
             if (folderMatches.length) {
-                return ( folderMatches.map(match => {
-                    const patternMatch = match.match[1];
-                    return {
-                        searchPath: match.folder.uri,
-                        pattern: patternMatch && normalizeGlobPattern(patternMatch)
-                    };
-                }));
+                return (
+                     (folderMatches.map(match => {
+                        const patternMatch = match.match[1];
+                        return {
+                            searchPath: match.folder.uri,
+                            pattern: patternMatch && normalizeGlobPattern(patternMatch)
+                        };
+                    }))
+                );
             }
             else {
                 const probableWorkspaceFolderNameMatch = searchPath.match(/\.[\/\\](.+)[\/\\]?/);
                 const probableWorkspaceFolderName = probableWorkspaceFolderNameMatch ? probableWorkspaceFolderNameMatch[1] : searchPath;
                 const searchPathNotFoundError = ( localizeWithPath(
-                    'vs/workbench/services/search/common/queryBuilder',
-                    'search.noWorkspaceWithName',
+                    _moduleId,
+                    0,
                     "Workspace folder does not exist: {0}",
                     probableWorkspaceFolderName
                 ));
-                throw new Error(searchPathNotFoundError);
+                throw ( (new Error(searchPathNotFoundError)));
             }
         }
     }
@@ -391,7 +394,7 @@ let QueryBuilder = class QueryBuilder {
         return {
             folder: folderUri,
             folderName: includeFolderName ? folderName : undefined,
-            excludePattern: ( Object.keys(excludePattern)).length > 0 ? excludePattern : undefined,
+            excludePattern: ( (Object.keys(excludePattern))).length > 0 ? excludePattern : undefined,
             fileEncoding: folderConfig.files && folderConfig.files.encoding,
             disregardIgnoreFiles: typeof options.disregardIgnoreFiles === 'boolean' ? options.disregardIgnoreFiles : !folderConfig.search?.useIgnoreFiles,
             disregardGlobalIgnoreFiles: typeof options.disregardGlobalIgnoreFiles === 'boolean' ? options.disregardGlobalIgnoreFiles : !folderConfig.search?.useGlobalIgnoreFiles,
@@ -400,13 +403,13 @@ let QueryBuilder = class QueryBuilder {
         };
     }
 };
-QueryBuilder = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IEditorGroupsService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IPathService))
-], QueryBuilder));
+QueryBuilder = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, IWorkspaceContextService))),
+    ( (__param(2, IEditorGroupsService))),
+    ( (__param(3, ILogService))),
+    ( (__param(4, IPathService)))
+], QueryBuilder)));
 function splitGlobFromPath(searchPath) {
     const globCharMatch = searchPath.match(/[\*\{\}\(\)\[\]\?]/);
     if (globCharMatch) {
@@ -433,8 +436,8 @@ function patternListToIExpression(...patterns) {
         undefined;
 }
 function splitGlobPattern(pattern) {
-    return ( splitGlobAware(pattern, ',')
-        .map(s => s.trim()))
+    return ( (splitGlobAware(pattern, ',')
+        .map(s => s.trim())))
         .filter(s => !!s.length);
 }
 function expandGlobalGlob(pattern) {
@@ -442,7 +445,9 @@ function expandGlobalGlob(pattern) {
         `**/${pattern}/**`,
         `**/${pattern}`
     ];
-    return ( patterns.map(p => p.replace(/\*\*\/\*\*/g, '**')));
+    return (
+         (patterns.map(p => p.replace(/\*\*\/\*\*/g, '**')))
+    );
 }
 function normalizeSlashes(pattern) {
     return pattern.replace(/\\/g, '/');
@@ -456,7 +461,7 @@ function escapeGlobPattern(path) {
     return path.replace(/([?*[\]])/g, '[$1]');
 }
 function resolveResourcesForSearchIncludes(resources, contextService) {
-    resources = distinct(resources, resource => ( resource.toString()));
+    resources = distinct(resources, resource => ( (resource.toString())));
     const folderPaths = [];
     const workspace = contextService.getWorkspace();
     if (resources) {

package/vscode/src/vs/workbench/services/storage/browser/storageService.d.ts

@@ -0,0 +1,41 @@
+import { IStorage } from '../../../../base/parts/storage/common/storage.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { AbstractStorageService, StorageScope } from '../../../../platform/storage/common/storage.js';
+import { IUserDataProfile } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+import { IAnyWorkspaceIdentifier } from '../../../../platform/workspace/common/workspace.js';
+import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.service.js';
+
+declare class BrowserStorageService extends AbstractStorageService {
+    private workspace;
+    private readonly userDataProfileService;
+    private readonly logService;
+    private static BROWSER_DEFAULT_FLUSH_INTERVAL;
+    private applicationStorage;
+    private applicationStorageDatabase;
+    private readonly applicationStoragePromise;
+    private profileStorage;
+    private profileStorageDatabase;
+    private profileStorageProfile;
+    private readonly profileStorageDisposables;
+    private workspaceStorage;
+    private workspaceStorageDatabase;
+    private readonly workspaceStorageDisposables;
+    get hasPendingUpdate(): boolean;
+    constructor(workspace: IAnyWorkspaceIdentifier, userDataProfileService: IUserDataProfileService, logService: ILogService);
+    private registerListeners;
+    protected doInitialize(): Promise<void>;
+    private createApplicationStorage;
+    private createProfileStorage;
+    private createWorkspaceStorage;
+    private updateIsNew;
+    protected getStorage(scope: StorageScope): IStorage | undefined;
+    protected getLogDetails(scope: StorageScope): string | undefined;
+    protected switchToProfile(toProfile: IUserDataProfile): Promise<void>;
+    protected switchToWorkspace(toWorkspace: IAnyWorkspaceIdentifier, preserveData: boolean): Promise<void>;
+    protected shouldFlushWhenIdle(): boolean;
+    close(): void;
+    clear(): Promise<void>;
+    hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;
+}
+
+export { BrowserStorageService };

package/vscode/src/vs/workbench/services/textMate/browser/textMateTokenizationFeature.service.d.ts

@@ -0,0 +1,11 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { IGrammar } from 'vscode-textmate';
+
+declare const ITextMateTokenizationService: ServiceIdentifier<ITextMateTokenizationService>;
+interface ITextMateTokenizationService {
+    readonly _serviceBrand: undefined;
+    createTokenizer(languageId: string): Promise<IGrammar | null>;
+    startDebugMode(printFn: (str: string) => void, onStop: () => void): void;
+}
+
+export { ITextMateTokenizationService };

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

@@ -1,15 +1,12 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 import { languagesExtPoint } from '../../language/common/languageService.js';
+const _moduleId = "vs/workbench/services/textMate/common/TMGrammars";
 const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'grammars',
     deps: [languagesExtPoint],
     jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/services/textMate/common/TMGrammars',
-            'vscode.extension.contributes.grammars',
-            'Contributes textmate tokenizers.'
-        )),
+        description: ( localizeWithPath(_moduleId, 0, 'Contributes textmate tokenizers.')),
         type: 'array',
         defaultSnippets: [{ body: [{ language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' }] }],
         items: {
@@ -18,42 +15,34 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
             properties: {
                 language: {
                     description: ( localizeWithPath(
-                        'vs/workbench/services/textMate/common/TMGrammars',
-                        'vscode.extension.contributes.grammars.language',
+                        _moduleId,
+                        1,
                         'Language identifier for which this syntax is contributed to.'
                     )),
                     type: 'string'
                 },
                 scopeName: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/textMate/common/TMGrammars',
-                        'vscode.extension.contributes.grammars.scopeName',
-                        'Textmate scope name used by the tmLanguage file.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 2, 'Textmate scope name used by the tmLanguage file.')),
                     type: 'string'
                 },
                 path: {
                     description: ( localizeWithPath(
-                        'vs/workbench/services/textMate/common/TMGrammars',
-                        'vscode.extension.contributes.grammars.path',
+                        _moduleId,
+                        3,
                         'Path of the tmLanguage file. The path is relative to the extension folder and typically starts with \'./syntaxes/\'.'
                     )),
                     type: 'string'
                 },
                 embeddedLanguages: {
                     description: ( localizeWithPath(
-                        'vs/workbench/services/textMate/common/TMGrammars',
-                        'vscode.extension.contributes.grammars.embeddedLanguages',
+                        _moduleId,
+                        4,
                         'A map of scope name to language id if this grammar contains embedded languages.'
                     )),
                     type: 'object'
                 },
                 tokenTypes: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/textMate/common/TMGrammars',
-                        'vscode.extension.contributes.grammars.tokenTypes',
-                        'A map of scope name to token types.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 5, 'A map of scope name to token types.')),
                     type: 'object',
                     additionalProperties: {
                         enum: ['string', 'comment', 'other']
@@ -61,8 +50,8 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 injectTo: {
                     description: ( localizeWithPath(
-                        'vs/workbench/services/textMate/common/TMGrammars',
-                        'vscode.extension.contributes.grammars.injectTo',
+                        _moduleId,
+                        6,
                         'List of language scope names to which this grammar is injected to.'
                     )),
                     type: 'array',
@@ -71,11 +60,7 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
                     }
                 },
                 balancedBracketScopes: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/textMate/common/TMGrammars',
-                        'vscode.extension.contributes.grammars.balancedBracketScopes',
-                        'Defines which scope names contain balanced brackets.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 7, 'Defines which scope names contain balanced brackets.')),
                     type: 'array',
                     items: {
                         type: 'string'
@@ -84,8 +69,8 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 unbalancedBracketScopes: {
                     description: ( localizeWithPath(
-                        'vs/workbench/services/textMate/common/TMGrammars',
-                        'vscode.extension.contributes.grammars.unbalancedBracketScopes',
+                        _moduleId,
+                        8,
                         'Defines which scope names do not contain balanced brackets.'
                     )),
                     type: 'array',

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

@@ -65,7 +65,10 @@ function toDecodeStream(source, options) {
                     bytesRead: bytesBuffered
                 }, options.guessEncoding);
                 if (detected.seemsBinary && options.acceptTextOnly) {
-                    throw new DecodeStreamError('Stream is binary but only text is accepted for decoding', 1 );
+                    throw ( new DecodeStreamError(
+                        'Stream is binary but only text is accepted for decoding',
+                        1
+                    ));
                 }
                 detected.encoding = await options.overwriteEncoding(detected.encoding);
                 decoder = await DecoderStream.create(detected.encoding);

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

@@ -122,7 +122,9 @@ let TextEditorService = class TextEditorService extends Disposable {
                 }
             });
         }
-        throw new Error(`ITextEditorService: Unable to create texteditor from ${JSON.stringify(input)}`);
+        throw ( new Error(
+            `ITextEditorService: Unable to create texteditor from ${JSON.stringify(input)}`
+        ));
     }
     createOrGetCached(resource, factoryFn, cachedFn) {
         let input = this.editorInputCache.get(resource);

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

@@ -28,13 +28,10 @@ import { IAccessibilityService } from '../../../../platform/accessibility/common
 import { PLAINTEXT_LANGUAGE_ID } from '../../../../editor/common/languages/modesRegistry.js';
 import { IExtensionService } from '../../extensions/common/extensions.service.js';
 var TextFileEditorModel_1;
+const _moduleId = "vs/workbench/services/textfile/common/textFileEditorModel";
 let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel {
     static { TextFileEditorModel_1 = this; }
-    static { this.TEXTFILE_SAVE_ENCODING_SOURCE = SaveSourceRegistry.registerSource('textFileEncoding.source', ( localizeWithPath(
-        'vs/workbench/services/textfile/common/textFileEditorModel',
-        'textFileCreate.source',
-        "File Encoding Changed"
-    ))); }
+    static { this.TEXTFILE_SAVE_ENCODING_SOURCE = SaveSourceRegistry.registerSource('textFileEncoding.source', ( localizeWithPath(_moduleId, 0, "File Encoding Changed"))); }
     static { this.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD = 500; }
     constructor(resource, preferredEncoding,
     preferredLanguageId, languageService, modelService, fileService, textFileService, workingCopyBackupService, logService, workingCopyService, filesConfigurationService, labelService, languageDetectionService, accessibilityService, pathService, extensionService) {
@@ -51,23 +48,23 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         this.labelService = labelService;
         this.pathService = pathService;
         this.extensionService = extensionService;
-        this._onDidChangeContent = this._register(( new Emitter()));
+        this._onDidChangeContent = this._register(( (new Emitter())));
         this.onDidChangeContent = this._onDidChangeContent.event;
-        this._onDidResolve = this._register(( new Emitter()));
+        this._onDidResolve = this._register(( (new Emitter())));
         this.onDidResolve = this._onDidResolve.event;
-        this._onDidChangeDirty = this._register(( new Emitter()));
+        this._onDidChangeDirty = this._register(( (new Emitter())));
         this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidSaveError = this._register(( new Emitter()));
+        this._onDidSaveError = this._register(( (new Emitter())));
         this.onDidSaveError = this._onDidSaveError.event;
-        this._onDidSave = this._register(( new Emitter()));
+        this._onDidSave = this._register(( (new Emitter())));
         this.onDidSave = this._onDidSave.event;
-        this._onDidRevert = this._register(( new Emitter()));
+        this._onDidRevert = this._register(( (new Emitter())));
         this.onDidRevert = this._onDidRevert.event;
-        this._onDidChangeEncoding = this._register(( new Emitter()));
+        this._onDidChangeEncoding = this._register(( (new Emitter())));
         this.onDidChangeEncoding = this._onDidChangeEncoding.event;
-        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this._onDidChangeOrphaned = this._register(( (new Emitter())));
         this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
-        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this._onDidChangeReadonly = this._register(( (new Emitter())));
         this.onDidChangeReadonly = this._onDidChangeReadonly.event;
         this.typeId = NO_TYPE_ID;
         this.capabilities = 0 ;
@@ -77,7 +74,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         this.ignoreDirtyOnModelContentChange = false;
         this.ignoreSaveFromSaveParticipants = false;
         this.lastModelContentChangeFromUndoRedo = undefined;
-        this.saveSequentializer = ( new TaskSequentializer());
+        this.saveSequentializer = ( (new TaskSequentializer()));
         this.dirty = false;
         this.inConflictMode = false;
         this.inOrphanMode = false;
@@ -500,7 +497,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         if (this.isResolved()) {
             this.textEditorModel.pushStackElement();
         }
-        const saveCancellation = ( new CancellationTokenSource());
+        const saveCancellation = ( (new CancellationTokenSource()));
         return this.saveSequentializer.run(versionId, (async () => {
             if (this.isResolved() && !options.skipSaveParticipants) {
                 try {
@@ -521,7 +518,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
                     }
                 }
                 catch (error) {
-                    this.logService.error(`[text file model] runSaveParticipants(${versionId}) - resulted in an error: ${( error.toString())}`, ( this.resource.toString()));
+                    this.logService.error(`[text file model] runSaveParticipants(${versionId}) - resulted in an error: ${( (error.toString()))}`, ( (this.resource.toString())));
                 }
             }
             if (saveCancellation.token.isCancellationRequested) {
@@ -571,7 +568,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         this._onDidSave.fire({ reason: options.reason, stat, source: options.source });
     }
     handleSaveError(error, versionId, options) {
-        (options.ignoreErrorHandler ? this.logService.trace : this.logService.error).apply(this.logService, [`[text file model] handleSaveError(${versionId}) - exit - resulted in a save error: ${( error.toString())}`, ( this.resource.toString())]);
+        (options.ignoreErrorHandler ? this.logService.trace : this.logService.error).apply(this.logService, [`[text file model] handleSaveError(${versionId}) - exit - resulted in a save error: ${( (error.toString()))}`, ( (this.resource.toString()))]);
         if (options.ignoreErrorHandler) {
             throw error;
         }
@@ -643,7 +640,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             this.trace('onMaybeShouldChangeEncoding() - ignoring because model is dirty');
             return;
         }
-        this.logService.info(`Adjusting encoding based on configured language override to '${encoding}' for ${( this.resource.toString(true))}.`);
+        this.logService.info(`Adjusting encoding based on configured language override to '${encoding}' for ${( (this.resource.toString(true)))}.`);
         return this.setEncodingInternal(encoding, 1 );
     }
     setEncoding(encoding, mode) {
@@ -692,7 +689,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         return this.preferredEncoding || this.contentEncoding;
     }
     trace(msg) {
-        this.logService.trace(`[text file model] ${msg}`, ( this.resource.toString()));
+        this.logService.trace(`[text file model] ${msg}`, ( (this.resource.toString())));
     }
     isResolved() {
         return !!this.textEditorModel;
@@ -708,19 +705,19 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         super.dispose();
     }
 };
-TextFileEditorModel = TextFileEditorModel_1 = ( __decorate([
-    ( __param(3, ILanguageService)),
-    ( __param(4, IModelService)),
-    ( __param(5, IFileService)),
-    ( __param(6, ITextFileService)),
-    ( __param(7, IWorkingCopyBackupService)),
-    ( __param(8, ILogService)),
-    ( __param(9, IWorkingCopyService)),
-    ( __param(10, IFilesConfigurationService)),
-    ( __param(11, ILabelService)),
-    ( __param(12, ILanguageDetectionService)),
-    ( __param(13, IAccessibilityService)),
-    ( __param(14, IPathService)),
-    ( __param(15, IExtensionService))
-], TextFileEditorModel));
+TextFileEditorModel = TextFileEditorModel_1 = ( (__decorate([
+    ( (__param(3, ILanguageService))),
+    ( (__param(4, IModelService))),
+    ( (__param(5, IFileService))),
+    ( (__param(6, ITextFileService))),
+    ( (__param(7, IWorkingCopyBackupService))),
+    ( (__param(8, ILogService))),
+    ( (__param(9, IWorkingCopyService))),
+    ( (__param(10, IFilesConfigurationService))),
+    ( (__param(11, ILabelService))),
+    ( (__param(12, ILanguageDetectionService))),
+    ( (__param(13, IAccessibilityService))),
+    ( (__param(14, IPathService))),
+    ( (__param(15, IExtensionService)))
+], TextFileEditorModel)));
 export { TextFileEditorModel };