@codingame/monaco-vscode-api 1.83.0-next.0 → 1.83.2

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.js

@@ -21,52 +21,38 @@ class LineRangeMapping {
         }
         const startDelta = extendedInputRange.startLineNumber - this.inputRange.startLineNumber;
         const endDelta = extendedInputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
-        return (
-             (new LineRangeMapping(extendedInputRange,  (new LineRange(
-                this.outputRange.startLineNumber + startDelta,
-                this.outputRange.lineCount - startDelta + endDelta
-            ))))
-        );
+        return ( new LineRangeMapping(extendedInputRange, ( new LineRange(
+            this.outputRange.startLineNumber + startDelta,
+            this.outputRange.lineCount - startDelta + endDelta
+        ))));
     }
     join(other) {
-        return (
-             (new LineRangeMapping(
-                this.inputRange.join(other.inputRange),
-                this.outputRange.join(other.outputRange)
-            ))
-        );
+        return ( new LineRangeMapping(
+            this.inputRange.join(other.inputRange),
+            this.outputRange.join(other.outputRange)
+        ));
     }
     get resultingDeltaFromOriginalToModified() {
         return this.outputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
     }
     toString() {
-        return `${( ( this.inputRange.toString()))} -> ${( ( this.outputRange.toString()))}`;
+        return `${( this.inputRange.toString())} -> ${( this.outputRange.toString())}`;
     }
     addOutputLineDelta(delta) {
-        return (
-             (new LineRangeMapping(this.inputRange, this.outputRange.delta(delta)))
-        );
+        return ( new LineRangeMapping(this.inputRange, this.outputRange.delta(delta)));
     }
     addInputLineDelta(delta) {
-        return (
-             (new LineRangeMapping(this.inputRange.delta(delta), this.outputRange))
-        );
+        return ( new LineRangeMapping(this.inputRange.delta(delta), this.outputRange));
     }
     reverse() {
-        return (
-             (new LineRangeMapping(this.outputRange, this.inputRange))
-        );
+        return ( new LineRangeMapping(this.outputRange, this.inputRange));
     }
 }
 class DocumentLineRangeMap {
     static betweenOutputs(inputToOutput1, inputToOutput2, inputLineCount) {
         const alignments = MappingAlignment.compute(inputToOutput1, inputToOutput2);
-        const mappings = ( (alignments.map(
-            (m) => ( (new LineRangeMapping(m.output1Range, m.output2Range)))
-        )));
-        return (
-             (new DocumentLineRangeMap(mappings, inputLineCount))
-        );
+        const mappings = ( alignments.map((m) => ( new LineRangeMapping(m.output1Range, m.output2Range))));
+        return ( new DocumentLineRangeMap(mappings, inputLineCount));
     }
     constructor(
     lineRangeMappings, inputLineCount) {
@@ -80,23 +66,16 @@ class DocumentLineRangeMap {
     project(lineNumber) {
         const lastBefore = findLast(this.lineRangeMappings, r => r.inputRange.startLineNumber <= lineNumber);
         if (!lastBefore) {
-            return (
-                 (new LineRangeMapping(
-                     (new LineRange(lineNumber, 1)),
-                     (new LineRange(lineNumber, 1))
-                ))
-            );
+            return ( new LineRangeMapping(( new LineRange(lineNumber, 1)), ( new LineRange(lineNumber, 1))));
         }
         if (lastBefore.inputRange.contains(lineNumber)) {
             return lastBefore;
         }
-        const containingRange = ( (new LineRange(lineNumber, 1)));
-        const mappedRange = ( (new LineRange(lineNumber +
+        const containingRange = ( new LineRange(lineNumber, 1));
+        const mappedRange = ( new LineRange(lineNumber +
             lastBefore.outputRange.endLineNumberExclusive -
-            lastBefore.inputRange.endLineNumberExclusive, 1)));
-        return (
-             (new LineRangeMapping(containingRange, mappedRange))
-        );
+            lastBefore.inputRange.endLineNumberExclusive, 1));
+        return ( new LineRangeMapping(containingRange, mappedRange));
     }
     get outputLineCount() {
         const last = lastOrDefault(this.lineRangeMappings);
@@ -104,31 +83,26 @@ class DocumentLineRangeMap {
         return this.inputLineCount + diff;
     }
     reverse() {
-        return (
-             (new DocumentLineRangeMap(
-                 (this.lineRangeMappings.map(r => r.reverse())),
-                this.outputLineCount
-            ))
-        );
+        return ( new DocumentLineRangeMap(( this.lineRangeMappings.map(r => r.reverse())), this.outputLineCount));
     }
 }
 class MappingAlignment {
     static compute(fromInputToOutput1, fromInputToOutput2) {
         const compareByStartLineNumber = compareBy((d) => d.inputRange.startLineNumber, numberComparator);
-        const combinedDiffs = concatArrays(( (fromInputToOutput1.map((diff) => ({ source: 0, diff })))), ( (fromInputToOutput2.map((diff) => ({ source: 1, diff }))))).sort(compareBy((d) => d.diff, compareByStartLineNumber));
-        const currentDiffs = [( (new Array())), ( (new Array()))];
+        const combinedDiffs = concatArrays(( fromInputToOutput1.map((diff) => ({ source: 0, diff }))), ( fromInputToOutput2.map((diff) => ({ source: 1, diff })))).sort(compareBy((d) => d.diff, compareByStartLineNumber));
+        const currentDiffs = [( new Array()), ( new Array())];
         const deltaFromBaseToInput = [0, 0];
-        const alignments = ( (new Array()));
+        const alignments = ( new Array());
         function pushAndReset(inputRange) {
-            const mapping1 = LineRangeMapping.join(currentDiffs[0]) || ( (new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[0]))));
-            const mapping2 = LineRangeMapping.join(currentDiffs[1]) || ( (new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[1]))));
-            alignments.push(( (new MappingAlignment(
+            const mapping1 = LineRangeMapping.join(currentDiffs[0]) || ( new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[0])));
+            const mapping2 = LineRangeMapping.join(currentDiffs[1]) || ( new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[1])));
+            alignments.push(( new MappingAlignment(
                 currentInputRange,
                 mapping1.extendInputRange(currentInputRange).outputRange,
                 currentDiffs[0],
                 mapping2.extendInputRange(currentInputRange).outputRange,
                 currentDiffs[1]
-            ))));
+            )));
             currentDiffs[0] = [];
             currentDiffs[1] = [];
         }
@@ -168,49 +142,39 @@ class DetailedLineRangeMapping extends LineRangeMapping {
         super(inputRange, outputRange);
         this.inputTextModel = inputTextModel;
         this.outputTextModel = outputTextModel;
-        this.rangeMappings = rangeMappings || [( (new RangeMapping(this.inputRange.toRange(), this.outputRange.toRange())))];
+        this.rangeMappings = rangeMappings || [( new RangeMapping(this.inputRange.toRange(), this.outputRange.toRange()))];
     }
     addOutputLineDelta(delta) {
-        return (
-             (new DetailedLineRangeMapping(
-                this.inputRange,
-                this.inputTextModel,
-                this.outputRange.delta(delta),
-                this.outputTextModel,
-                 (this.rangeMappings.map(d => d.addOutputLineDelta(delta)))
-            ))
-        );
+        return ( new DetailedLineRangeMapping(
+            this.inputRange,
+            this.inputTextModel,
+            this.outputRange.delta(delta),
+            this.outputTextModel,
+            ( this.rangeMappings.map(d => d.addOutputLineDelta(delta)))
+        ));
     }
     addInputLineDelta(delta) {
-        return (
-             (new DetailedLineRangeMapping(
-                this.inputRange.delta(delta),
-                this.inputTextModel,
-                this.outputRange,
-                this.outputTextModel,
-                 (this.rangeMappings.map(d => d.addInputLineDelta(delta)))
-            ))
-        );
+        return ( new DetailedLineRangeMapping(
+            this.inputRange.delta(delta),
+            this.inputTextModel,
+            this.outputRange,
+            this.outputTextModel,
+            ( this.rangeMappings.map(d => d.addInputLineDelta(delta)))
+        ));
     }
     join(other) {
-        return (
-             (new DetailedLineRangeMapping(
-                this.inputRange.join(other.inputRange),
-                this.inputTextModel,
-                this.outputRange.join(other.outputRange),
-                this.outputTextModel
-            ))
-        );
+        return ( new DetailedLineRangeMapping(
+            this.inputRange.join(other.inputRange),
+            this.inputTextModel,
+            this.outputRange.join(other.outputRange),
+            this.outputTextModel
+        ));
     }
     getLineEdit() {
-        return (
-             (new LineRangeEdit(this.inputRange, this.getOutputLines()))
-        );
+        return ( new LineRangeEdit(this.inputRange, this.getOutputLines()));
     }
     getReverseLineEdit() {
-        return (
-             (new LineRangeEdit(this.outputRange, this.getInputLines()))
-        );
+        return ( new LineRangeEdit(this.outputRange, this.getInputLines()));
     }
     getOutputLines() {
         return this.outputRange.getLines(this.outputTextModel);
@@ -231,29 +195,23 @@ class RangeMapping {
         return `${rangeToString(this.inputRange)} -> ${rangeToString(this.outputRange)}`;
     }
     addOutputLineDelta(deltaLines) {
-        return (
-             (new RangeMapping(this.inputRange,  (new Range(
-                this.outputRange.startLineNumber + deltaLines,
-                this.outputRange.startColumn,
-                this.outputRange.endLineNumber + deltaLines,
-                this.outputRange.endColumn
-            ))))
-        );
+        return ( new RangeMapping(this.inputRange, ( new Range(
+            this.outputRange.startLineNumber + deltaLines,
+            this.outputRange.startColumn,
+            this.outputRange.endLineNumber + deltaLines,
+            this.outputRange.endColumn
+        ))));
     }
     addInputLineDelta(deltaLines) {
-        return (
-             (new RangeMapping( (new Range(
-                this.inputRange.startLineNumber + deltaLines,
-                this.inputRange.startColumn,
-                this.inputRange.endLineNumber + deltaLines,
-                this.inputRange.endColumn
-            )), this.outputRange))
-        );
+        return ( new RangeMapping(( new Range(
+            this.inputRange.startLineNumber + deltaLines,
+            this.inputRange.startColumn,
+            this.inputRange.endLineNumber + deltaLines,
+            this.inputRange.endColumn
+        )), this.outputRange));
     }
     reverse() {
-        return (
-             (new RangeMapping(this.outputRange, this.inputRange))
-        );
+        return ( new RangeMapping(this.outputRange, this.inputRange));
     }
 }
 class DocumentRangeMap {
@@ -268,31 +226,25 @@ class DocumentRangeMap {
     project(position) {
         const lastBefore = findLast(this.rangeMappings, r => r.inputRange.getStartPosition().isBeforeOrEqual(position));
         if (!lastBefore) {
-            return (
-                 (new RangeMapping(
-                    Range.fromPositions(position, position),
-                    Range.fromPositions(position, position)
-                ))
-            );
+            return ( new RangeMapping(
+                Range.fromPositions(position, position),
+                Range.fromPositions(position, position)
+            ));
         }
         if (rangeContainsPosition(lastBefore.inputRange, position)) {
             return lastBefore;
         }
         const dist = lengthBetweenPositions(lastBefore.inputRange.getEndPosition(), position);
         const outputPos = addLength(lastBefore.outputRange.getEndPosition(), dist);
-        return (
-             (new RangeMapping(Range.fromPositions(position), Range.fromPositions(outputPos)))
-        );
+        return ( new RangeMapping(Range.fromPositions(position), Range.fromPositions(outputPos)));
     }
     projectRange(range) {
         const start = this.project(range.getStartPosition());
         const end = this.project(range.getEndPosition());
-        return (
-             (new RangeMapping(
-                start.inputRange.plusRange(end.inputRange),
-                start.outputRange.plusRange(end.outputRange)
-            ))
-        );
+        return ( new RangeMapping(
+            start.inputRange.plusRange(end.inputRange),
+            start.outputRange.plusRange(end.outputRange)
+        ));
     }
     get outputLineCount() {
         const last = lastOrDefault(this.rangeMappings);
@@ -300,12 +252,7 @@ class DocumentRangeMap {
         return this.inputLineCount + diff;
     }
     reverse() {
-        return (
-             (new DocumentRangeMap(
-                 (this.rangeMappings.map(m => m.reverse())),
-                this.outputLineCount
-            ))
-        );
+        return ( new DocumentRangeMap(( this.rangeMappings.map(m => m.reverse())), this.outputLineCount));
     }
 }
 export { DetailedLineRangeMapping, DocumentLineRangeMap, DocumentRangeMap, LineRangeMapping, MappingAlignment, RangeMapping };

package/vscode/src/vs/workbench/contrib/snippets/browser/snippetsService.js

@@ -25,45 +25,45 @@ import { IUserDataProfileService } from '../../../services/userDataProfile/commo
 import { insertInto } from 'monaco-editor/esm/vs/base/common/arrays.js';
 var SnippetEnablement_1, SnippetUsageTimestamps_1;
 var snippetExt;
-( ((function(snippetExt) {
+( (function(snippetExt) {
     function toValidSnippet(extension, snippet, languageService) {
         if (isFalsyOrWhitespace(snippet.path)) {
-            extension.collector.error(( (localize(
+            extension.collector.error(( localize(
                 'invalid.path.0',
                 "Expected string in `contributes.{0}.path`. Provided value: {1}",
                 extension.description.name,
                 String(snippet.path)
-            ))));
+            )));
             return null;
         }
         if (isFalsyOrWhitespace(snippet.language) && !snippet.path.endsWith('.code-snippets')) {
-            extension.collector.error(( (localize(
+            extension.collector.error(( localize(
                 'invalid.language.0',
                 "When omitting the language, the value of `contributes.{0}.path` must be a `.code-snippets`-file. Provided value: {1}",
                 extension.description.name,
                 String(snippet.path)
-            ))));
+            )));
             return null;
         }
         if (!isFalsyOrWhitespace(snippet.language) && !languageService.isRegisteredLanguageId(snippet.language)) {
-            extension.collector.error(( (localize(
+            extension.collector.error(( localize(
                 'invalid.language',
                 "Unknown language in `contributes.{0}.language`. Provided value: {1}",
                 extension.description.name,
                 String(snippet.language)
-            ))));
+            )));
             return null;
         }
         const extensionLocation = extension.description.extensionLocation;
         const snippetLocation = resources.joinPath(extensionLocation, snippet.path);
         if (!resources.isEqualOrParent(snippetLocation, extensionLocation)) {
-            extension.collector.error(( (localize(
+            extension.collector.error(( localize(
                 'invalid.path.1',
                 "Expected `contributes.{0}.path` ({1}) to be included inside extension's folder ({2}). This might make the extension non-portable.",
                 extension.description.name,
                 snippetLocation.path,
                 extensionLocation.path
-            ))));
+            )));
             return null;
         }
         return {
@@ -73,7 +73,7 @@ var snippetExt;
     }
     snippetExt.toValidSnippet = toValidSnippet;
     snippetExt.snippetsContribution = {
-        description: ( (localize('vscode.extension.contributes.snippets', 'Contributes snippets.'))),
+        description: ( localize('vscode.extension.contributes.snippets', 'Contributes snippets.')),
         type: 'array',
         defaultSnippets: [{ body: [{ language: '', path: '' }] }],
         items: {
@@ -81,28 +81,28 @@ var snippetExt;
             defaultSnippets: [{ body: { language: '${1:id}', path: './snippets/${2:id}.json.' } }],
             properties: {
                 language: {
-                    description: ( (localize(
+                    description: ( localize(
                         'vscode.extension.contributes.snippets-language',
                         'Language identifier for which this snippet is contributed to.'
-                    ))),
+                    )),
                     type: 'string'
                 },
                 path: {
-                    description: ( (localize(
+                    description: ( localize(
                         'vscode.extension.contributes.snippets-path',
                         'Path of the snippets file. The path is relative to the extension folder and typically starts with \'./snippets/\'.'
-                    ))),
+                    )),
                     type: 'string'
                 }
             }
         }
     };
-    snippetExt.point = ( (ExtensionsRegistry.registerExtensionPoint({
+    snippetExt.point = ( ExtensionsRegistry.registerExtensionPoint({
         extensionPoint: 'snippets',
         deps: [languagesExtPoint],
         jsonSchema: snippetExt.snippetsContribution
-    })));
-})(snippetExt || (snippetExt = {}))));
+    }));
+})(snippetExt || (snippetExt = {})));
 function watch(service, resource, callback) {
     return combinedDisposable(service.watch(resource), service.onDidFilesChange(e => {
         if (e.affects(resource)) {
@@ -121,20 +121,18 @@ let SnippetEnablement = class SnippetEnablement {
             data = JSON.parse(raw);
         }
         catch { }
-        this._ignored = isStringArray(data) ? ( (new Set(data))) : ( (new Set()));
+        this._ignored = isStringArray(data) ? ( new Set(data)) : ( new Set());
     }
     isIgnored(id) {
-        return (
-             (this._ignored.has(id))
-        );
+        return ( this._ignored.has(id));
     }
     updateIgnored(id, value) {
         let changed = false;
-        if (( (this._ignored.has(id))) && !value) {
+        if (( this._ignored.has(id)) && !value) {
             this._ignored.delete(id);
             changed = true;
         }
-        else if (!( (this._ignored.has(id))) && value) {
+        else if (!( this._ignored.has(id)) && value) {
             this._ignored.add(id);
             changed = true;
         }
@@ -143,9 +141,9 @@ let SnippetEnablement = class SnippetEnablement {
         }
     }
 };
-SnippetEnablement = SnippetEnablement_1 = ( (__decorate([
-    ( (__param(0, IStorageService)))
-], SnippetEnablement)));
+SnippetEnablement = SnippetEnablement_1 = ( __decorate([
+    ( __param(0, IStorageService))
+], SnippetEnablement));
 let SnippetUsageTimestamps = class SnippetUsageTimestamps {
     static { SnippetUsageTimestamps_1 = this; }
     static { this._key = 'snippets.usageTimestamps'; }
@@ -159,7 +157,7 @@ let SnippetUsageTimestamps = class SnippetUsageTimestamps {
         catch {
             data = [];
         }
-        this._usages = Array.isArray(data) ? ( (new Map(data))) : ( (new Map()));
+        this._usages = Array.isArray(data) ? ( new Map(data)) : ( new Map());
     }
     getUsageTimestamp(id) {
         return this._usages.get(id);
@@ -171,9 +169,9 @@ let SnippetUsageTimestamps = class SnippetUsageTimestamps {
         this._storageService.store(SnippetUsageTimestamps_1._key, JSON.stringify(all), 0 , 0 );
     }
 };
-SnippetUsageTimestamps = SnippetUsageTimestamps_1 = ( (__decorate([
-    ( (__param(0, IStorageService)))
-], SnippetUsageTimestamps)));
+SnippetUsageTimestamps = SnippetUsageTimestamps_1 = ( __decorate([
+    ( __param(0, IStorageService))
+], SnippetUsageTimestamps));
 let SnippetsService = class SnippetsService {
     constructor(_environmentService, _userDataProfileService, _contextService, _languageService, _logService, _fileService, _textfileService, _extensionResourceLoaderService, lifecycleService, instantiationService, languageConfigurationService) {
         this._environmentService = _environmentService;
@@ -184,15 +182,15 @@ let SnippetsService = class SnippetsService {
         this._fileService = _fileService;
         this._textfileService = _textfileService;
         this._extensionResourceLoaderService = _extensionResourceLoaderService;
-        this._disposables = ( (new DisposableStore()));
+        this._disposables = ( new DisposableStore());
         this._pendingWork = [];
-        this._files = ( (new ResourceMap()));
+        this._files = ( new ResourceMap());
         this._pendingWork.push(Promise.resolve(lifecycleService.when(3 ).then(() => {
             this._initExtensionSnippets();
             this._initUserSnippets();
             this._initWorkspaceSnippets();
         })));
-        setSnippetSuggestSupport(( (new SnippetCompletionProvider(this._languageService, this, languageConfigurationService))));
+        setSnippetSuggestSupport(( new SnippetCompletionProvider(this._languageService, this, languageConfigurationService)));
         this._enablement = instantiationService.createInstance(SnippetEnablement);
         this._usageTimestamps = instantiationService.createInstance(SnippetUsageTimestamps);
     }
@@ -215,9 +213,7 @@ let SnippetsService = class SnippetsService {
     }
     async getSnippetFiles() {
         await this._joinSnippets();
-        return (
-             (this._files.values())
-        );
+        return ( this._files.values());
     }
     async getSnippets(languageId, opts) {
         await this._joinSnippets();
@@ -225,18 +221,18 @@ let SnippetsService = class SnippetsService {
         const promises = [];
         if (languageId) {
             if (this._languageService.isRegisteredLanguageId(languageId)) {
-                for (const file of ( (this._files.values()))) {
+                for (const file of ( this._files.values())) {
                     promises.push(file.load()
                         .then(file => file.select(languageId, result))
-                        .catch(err => this._logService.error(err, ( (file.location.toString())))));
+                        .catch(err => this._logService.error(err, ( file.location.toString()))));
                 }
             }
         }
         else {
-            for (const file of ( (this._files.values()))) {
+            for (const file of ( this._files.values())) {
                 promises.push(file.load()
                     .then(file => insertInto(result, result.length, file.data))
-                    .catch(err => this._logService.error(err, ( (file.location.toString())))));
+                    .catch(err => this._logService.error(err, ( file.location.toString()))));
             }
         }
         await Promise.all(promises);
@@ -245,7 +241,7 @@ let SnippetsService = class SnippetsService {
     getSnippetsSync(languageId, opts) {
         const result = [];
         if (this._languageService.isRegisteredLanguageId(languageId)) {
-            for (const file of ( (this._files.values()))) {
+            for (const file of ( this._files.values())) {
                 file.load().catch(_err => { });
                 file.select(languageId, result);
             }
@@ -325,30 +321,26 @@ let SnippetsService = class SnippetsService {
                         }
                     }
                     else {
-                        const file = ( (new SnippetFile(
+                        const file = ( new SnippetFile(
                             3 ,
                             validContribution.location,
                             validContribution.language ? [validContribution.language] : undefined,
                             extension.description,
                             this._fileService,
                             this._extensionResourceLoaderService
-                        )));
+                        ));
                         this._files.set(file.location, file);
                         if (this._environmentService.isExtensionDevelopment) {
                             file.load().then(file => {
-                                if (( (file.data.some(snippet => snippet.isBogous)))) {
-                                    extension.collector.warn(( (localize(
+                                if (( file.data.some(snippet => snippet.isBogous))) {
+                                    extension.collector.warn(( localize(
                                         'badVariableUse',
                                         "One or more snippets from the extension '{0}' very likely confuse snippet-variables and snippet-placeholders (see https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax for more details)",
                                         extension.description.name
-                                    ))));
+                                    )));
                                 }
                             }, err => {
-                                extension.collector.warn(( (localize(
-                                    'badFile',
-                                    "The snippet file \"{0}\" could not be read.",
-                                     (file.location.toString())
-                                ))));
+                                extension.collector.warn(( localize('badFile', "The snippet file \"{0}\" could not be read.", ( file.location.toString()))));
                             });
                         }
                     }
@@ -357,7 +349,7 @@ let SnippetsService = class SnippetsService {
         });
     }
     _initWorkspaceSnippets() {
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         const updateWorkspaceSnippets = () => {
             disposables.clear();
             this._pendingWork.push(this._initWorkspaceFolderSnippets(this._contextService.getWorkspace(), disposables));
@@ -368,7 +360,7 @@ let SnippetsService = class SnippetsService {
         updateWorkspaceSnippets();
     }
     async _initWorkspaceFolderSnippets(workspace, bucket) {
-        const promises = ( (workspace.folders.map(async (folder) => {
+        const promises = ( workspace.folders.map(async (folder) => {
             const snippetFolder = folder.toResource('.vscode');
             const value = await this._fileService.exists(snippetFolder);
             if (value) {
@@ -381,11 +373,11 @@ let SnippetsService = class SnippetsService {
                     }
                 }));
             }
-        })));
+        }));
         await Promise.all(promises);
     }
     async _initUserSnippets() {
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         const updateUserSnippets = async () => {
             disposables.clear();
             const userSnippetsFolder = this._userDataProfileService.currentProfile.snippetsHome;
@@ -399,7 +391,7 @@ let SnippetsService = class SnippetsService {
         await updateUserSnippets();
     }
     _initFolderSnippets(source, folder, bucket) {
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         const addFolderSnippets = async () => {
             disposables.clear();
             if (!(await this._fileService.exists(folder))) {
@@ -412,7 +404,7 @@ let SnippetsService = class SnippetsService {
                 }
             }
             catch (err) {
-                this._logService.error(`Failed snippets from folder '${( ( folder.toString()))}'`, err);
+                this._logService.error(`Failed snippets from folder '${( folder.toString())}'`, err);
             }
         };
         bucket.add(this._textfileService.files.onDidSave(e => {
@@ -428,43 +420,43 @@ let SnippetsService = class SnippetsService {
         const ext = resources.extname(uri);
         if (source === 1  && ext === '.json') {
             const langName = resources.basename(uri).replace(/\.json/, '');
-            this._files.set(uri, ( (new SnippetFile(
+            this._files.set(uri, ( new SnippetFile(
                 source,
                 uri,
                 [langName],
                 undefined,
                 this._fileService,
                 this._extensionResourceLoaderService
-            ))));
+            )));
         }
         else if (ext === '.code-snippets') {
-            this._files.set(uri, ( (new SnippetFile(
+            this._files.set(uri, ( new SnippetFile(
                 source,
                 uri,
                 undefined,
                 undefined,
                 this._fileService,
                 this._extensionResourceLoaderService
-            ))));
+            )));
         }
         return {
             dispose: () => this._files.delete(uri)
         };
     }
 };
-SnippetsService = ( (__decorate([
-    ( (__param(0, IEnvironmentService))),
-    ( (__param(1, IUserDataProfileService))),
-    ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, ILanguageService))),
-    ( (__param(4, ILogService))),
-    ( (__param(5, IFileService))),
-    ( (__param(6, ITextFileService))),
-    ( (__param(7, IExtensionResourceLoaderService))),
-    ( (__param(8, ILifecycleService))),
-    ( (__param(9, IInstantiationService))),
-    ( (__param(10, ILanguageConfigurationService)))
-], SnippetsService)));
+SnippetsService = ( __decorate([
+    ( __param(0, IEnvironmentService)),
+    ( __param(1, IUserDataProfileService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, ILanguageService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IFileService)),
+    ( __param(6, ITextFileService)),
+    ( __param(7, IExtensionResourceLoaderService)),
+    ( __param(8, ILifecycleService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, ILanguageConfigurationService))
+], SnippetsService));
 function getNonWhitespacePrefix(model, position) {
     const MAX_PREFIX_LENGTH = 100;
     const line = model.getLineContent(position.lineNumber).substr(0, position.column - 1);