@codingame/monaco-vscode-files-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/services/textfile/browser/textFileService.js

@@ -52,10 +52,35 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/sear
 
 var AbstractTextFileService_1;
 let AbstractTextFileService = class AbstractTextFileService extends Disposable {
-    static { AbstractTextFileService_1 = this; }
-    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localize(14297, "File Created"))); }
-    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localize(14298, "File Replaced"))); }
-    constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService) {
+    static {
+        AbstractTextFileService_1 = this;
+    }
+    static {
+        this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource("textFileCreate.source", ( localize(14689, "File Created")));
+    }
+    static {
+        this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource("textFileOverwrite.source", ( localize(14690, "File Replaced")));
+    }
+    constructor(
+        fileService,
+        untitledTextEditorService,
+        lifecycleService,
+        instantiationService,
+        modelService,
+        environmentService,
+        dialogService,
+        fileDialogService,
+        textResourceConfigurationService,
+        filesConfigurationService,
+        codeEditorService,
+        pathService,
+        workingCopyFileService,
+        uriIdentityService,
+        languageService,
+        logService,
+        elevatedFileService,
+        decorationsService
+    ) {
         super();
         this.fileService = fileService;
         this.lifecycleService = lifecycleService;
@@ -83,20 +108,28 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             constructor(files) {
                 super();
                 this.files = files;
-                this.label = ( localize(14299, "Text File Model Decorations"));
+                this.label = ( localize(14691, "Text File Model Decorations"));
                 this._onDidChange = this._register(( new Emitter()));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
             }
             registerListeners() {
-                this._register(this.files.onDidResolve(({ model }) => {
+                this._register(this.files.onDidResolve((
+                    {
+                        model
+                    }
+                ) => {
                     if (model.isReadonly() || model.hasState(TextFileEditorModelState.ORPHAN)) {
                         this._onDidChange.fire([model.resource]);
                     }
                 }));
                 this._register(this.files.onDidRemove(modelUri => this._onDidChange.fire([modelUri])));
-                this._register(this.files.onDidChangeReadonly(model => this._onDidChange.fire([model.resource])));
-                this._register(this.files.onDidChangeOrphaned(model => this._onDidChange.fire([model.resource])));
+                this._register(
+                    this.files.onDidChangeReadonly(model => this._onDidChange.fire([model.resource]))
+                );
+                this._register(
+                    this.files.onDidChangeOrphaned(model => this._onDidChange.fire([model.resource]))
+                );
             }
             provideDecorations(uri) {
                 const model = this.files.get(uri);
@@ -110,20 +143,20 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(14300, "Deleted, Read-only")),
+                        tooltip: ( localize(14692, "Deleted, Read-only"))
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(14301, "Read-only")),
+                        tooltip: ( localize(14693, "Read-only"))
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(14302, "Deleted")),
+                        tooltip: ( localize(14694, "Deleted"))
                     };
                 }
                 return undefined;
@@ -145,7 +178,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         return {
             ...bufferStream,
             encoding: decoder.detected.encoding || UTF8,
-            value: await consumeStream(decoder.stream, strings => strings.join(''))
+            value: await consumeStream(decoder.stream, strings => strings.join(""))
         };
     }
     async readStream(resource, options) {
@@ -165,18 +198,16 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                 ...content,
                 value: bufferToStream(content.value)
             };
-        }
-        else {
+        } else {
             bufferStream = await this.fileService.readFileStream(resource, options, cts.token);
         }
         try {
             const decoder = await this.doGetDecodedStream(resource, bufferStream.value, options);
             return [bufferStream, decoder];
-        }
-        catch (error) {
+        } catch (error) {
             cts.dispose(true);
             if (error.decodeStreamErrorKind === DecodeStreamErrorKind.STREAM_IS_BINARY) {
-                throw ( new TextFileOperationError(( localize(14303, "File seems to be binary and cannot be opened as text")), TextFileOperationResult.FILE_IS_BINARY, options));
+                throw ( new TextFileOperationError(( localize(14695, "File seems to be binary and cannot be opened as text")), TextFileOperationResult.FILE_IS_BINARY, options));
             }
             else {
                 throw error;
@@ -184,7 +215,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         }
     }
     async create(operations, undoInfo) {
-        const operationsWithContents = await Promise.all(( operations.map(async (operation) => {
+        const operationsWithContents = await Promise.all(( operations.map(async operation => {
             const contents = await this.getEncodedReadable(operation.resource, operation.value);
             return {
                 resource: operation.resource,
@@ -202,15 +233,18 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         return this.fileService.writeFile(resource, readable, options);
     }
     async getEncodedReadable(resource, value, options) {
-        const { encoding, addBOM } = await this.encoding.getWriteEncoding(resource, options);
+        const {
+            encoding,
+            addBOM
+        } = await this.encoding.getWriteEncoding(resource, options);
         if (encoding === UTF8 && !addBOM) {
-            return typeof value === 'undefined'
-                ? undefined
-                : toBufferOrReadable(value);
+            return typeof value === "undefined" ? undefined : toBufferOrReadable(value);
         }
-        value = value || '';
-        const snapshot = typeof value === 'string' ? stringToSnapshot(value) : value;
-        return toEncodeReadable(snapshot, encoding, { addBOM });
+        value = value || "";
+        const snapshot = typeof value === "string" ? stringToSnapshot(value) : value;
+        return toEncodeReadable(snapshot, encoding, {
+            addBOM
+        });
     }
     async getDecodedStream(resource, value, options) {
         return (await this.doGetDecodedStream(resource, value, options)).stream;
@@ -218,11 +252,9 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     doGetDecodedStream(resource, stream, options) {
         return toDecodeStream(stream, {
             acceptTextOnly: options?.acceptTextOnly ?? false,
-            guessEncoding: options?.autoGuessEncoding ||
-                this.textResourceConfigurationService.getValue(resource, 'files.autoGuessEncoding'),
-            candidateGuessEncodings: options?.candidateGuessEncodings ||
-                this.textResourceConfigurationService.getValue(resource, 'files.candidateGuessEncodings'),
-            overwriteEncoding: async (detectedEncoding) => this.validateDetectedEncoding(resource, detectedEncoding ?? undefined, options)
+            guessEncoding: options?.autoGuessEncoding || this.textResourceConfigurationService.getValue(resource, "files.autoGuessEncoding"),
+            candidateGuessEncodings: options?.candidateGuessEncodings || this.textResourceConfigurationService.getValue(resource, "files.candidateGuessEncodings"),
+            overwriteEncoding: async detectedEncoding => this.validateDetectedEncoding(resource, detectedEncoding ?? undefined, options)
         });
     }
     getEncoding(resource) {
@@ -232,14 +264,14 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     async resolveDecoding(resource, options) {
         return {
             preferredEncoding: (await this.encoding.getPreferredReadEncoding(resource, options, undefined)).encoding,
-            guessEncoding: options?.autoGuessEncoding ||
-                this.textResourceConfigurationService.getValue(resource, 'files.autoGuessEncoding'),
-            candidateGuessEncodings: options?.candidateGuessEncodings ||
-                this.textResourceConfigurationService.getValue(resource, 'files.candidateGuessEncodings'),
+            guessEncoding: options?.autoGuessEncoding || this.textResourceConfigurationService.getValue(resource, "files.autoGuessEncoding"),
+            candidateGuessEncodings: options?.candidateGuessEncodings || this.textResourceConfigurationService.getValue(resource, "files.candidateGuessEncodings")
         };
     }
     async validateDetectedEncoding(resource, detectedEncoding, options) {
-        const { encoding } = await this.encoding.getPreferredReadEncoding(resource, options, detectedEncoding);
+        const {
+            encoding
+        } = await this.encoding.getPreferredReadEncoding(resource, options, detectedEncoding);
         return encoding;
     }
     resolveEncoding(resource, options) {
@@ -271,7 +303,10 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     }
     async saveAs(source, target, options) {
         if (!target) {
-            target = await this.fileDialogService.pickFileToSave(await this.suggestSavePath(options?.suggestedTarget ?? source), options?.availableFileSystems);
+            target = await this.fileDialogService.pickFileToSave(
+                await this.suggestSavePath(options?.suggestedTarget ?? source),
+                options?.availableFileSystems
+            );
         }
         if (!target) {
             return;
@@ -280,16 +315,23 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             const confirmed = await this.confirmMakeWriteable(target);
             if (!confirmed) {
                 return;
-            }
-            else {
+            } else {
                 this.filesConfigurationService.updateReadonly(target, false);
             }
         }
         if (isEqual(source, target)) {
-            return this.save(source, { ...options, force: true  });
+            return this.save(source, {
+                ...options,
+                force: true
+            });
         }
         if (this.fileService.hasProvider(source) && this.uriIdentityService.extUri.isEqual(source, target) && (await this.fileService.exists(source))) {
-            await this.workingCopyFileService.move([{ file: { source, target } }], CancellationToken.None);
+            await this.workingCopyFileService.move([{
+                file: {
+                    source,
+                    target
+                }
+            }], CancellationToken.None);
             const success = await this.save(source, options);
             if (!success) {
                 await this.save(target, options);
@@ -306,8 +348,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             if (textFileModel?.isResolved()) {
                 resolvedTextModel = textFileModel;
             }
-        }
-        else {
+        } else {
             const untitledTextModel = this.untitled.get(source);
             if (untitledTextModel?.isResolved()) {
                 resolvedTextModel = untitledTextModel;
@@ -331,8 +372,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         }
         try {
             await this.revert(source);
-        }
-        catch (error) {
+        } catch (error) {
             this.logService.error(error);
         }
         if (source.scheme === Schemas.untitled) {
@@ -343,7 +383,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     async doSaveAsTextFile(sourceModel, source, target, options) {
         let sourceModelEncoding = undefined;
         const sourceModelWithEncodingSupport = sourceModel;
-        if (typeof sourceModelWithEncodingSupport.getEncoding === 'function') {
+        if (typeof sourceModelWithEncodingSupport.getEncoding === "function") {
             sourceModelEncoding = sourceModelWithEncodingSupport.getEncoding();
         }
         let targetExists = false;
@@ -354,15 +394,18 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         else {
             targetExists = await this.fileService.exists(target);
             if (!targetExists) {
-                await this.create([{ resource: target, value: '' }]);
+                await this.create([{
+                    resource: target,
+                    value: ""
+                }]);
             }
             try {
-                targetModel = await this.files.resolve(target, { encoding: sourceModelEncoding });
-            }
-            catch (error) {
+                targetModel = await this.files.resolve(target, {
+                    encoding: sourceModelEncoding
+                });
+            } catch (error) {
                 if (targetExists) {
-                    if (error.textFileOperationResult === TextFileOperationResult.FILE_IS_BINARY ||
-                        error.fileOperationResult === FileOperationResult.FILE_TOO_LARGE) {
+                    if (error.textFileOperationResult === TextFileOperationResult.FILE_IS_BINARY || error.fileOperationResult === FileOperationResult.FILE_TOO_LARGE) {
                         await this.fileService.del(target);
                         return this.doSaveAsTextFile(sourceModel, source, target, options);
                     }
@@ -371,10 +414,13 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             }
         }
         let write;
-        if (sourceModel instanceof UntitledTextEditorModel && sourceModel.hasAssociatedFilePath && targetExists && this.uriIdentityService.extUri.isEqual(target, toLocalResource(sourceModel.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme))) {
+        if (sourceModel instanceof UntitledTextEditorModel && sourceModel.hasAssociatedFilePath && targetExists && this.uriIdentityService.extUri.isEqual(target, toLocalResource(
+            sourceModel.resource,
+            this.environmentService.remoteAuthority,
+            this.pathService.defaultUriScheme
+        ))) {
             write = await this.confirmOverwrite(target);
-        }
-        else {
+        } else {
             write = true;
         }
         if (!write) {
@@ -385,8 +431,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             if (sourceModel.isResolved()) {
                 sourceTextModel = sourceModel.textEditorModel ?? undefined;
             }
-        }
-        else {
+        } else {
             sourceTextModel = sourceModel;
         }
         let targetTextModel = undefined;
@@ -395,12 +440,23 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         }
         if (sourceTextModel && targetTextModel) {
             targetModel.updatePreferredEncoding(sourceModelEncoding);
-            this.modelService.updateModel(targetTextModel, createTextBufferFactoryFromSnapshot(sourceTextModel.createSnapshot()));
+            this.modelService.updateModel(
+                targetTextModel,
+                createTextBufferFactoryFromSnapshot(sourceTextModel.createSnapshot())
+            );
             const sourceLanguageId = sourceTextModel.getLanguageId();
             const targetLanguageId = targetTextModel.getLanguageId();
             if (sourceLanguageId !== PLAINTEXT_LANGUAGE_ID && targetLanguageId === PLAINTEXT_LANGUAGE_ID) {
                 targetTextModel.setLanguage(sourceLanguageId);
             }
+            const sourceOptions = sourceTextModel.getOptions();
+            targetTextModel.updateOptions({
+                tabSize: sourceOptions.tabSize,
+                indentSize: sourceOptions.indentSize,
+                insertSpaces: sourceOptions.insertSpaces
+            });
+            const sourceEOL = sourceTextModel.getEndOfLineSequence();
+            targetTextModel.setEOL(sourceEOL);
             const sourceTransientProperties = this.codeEditorService.getTransientModelProperties(sourceTextModel);
             if (sourceTransientProperties) {
                 for (const [key, value] of sourceTransientProperties) {
@@ -420,33 +476,37 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         });
     }
     async confirmOverwrite(resource) {
-        const { confirmed } = await this.dialogService.confirm({
-            type: 'warning',
+        const {
+            confirmed
+        } = await this.dialogService.confirm({
+            type: "warning",
             message: ( localize(
-                14304,
+                14696,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                14305,
+                14697,
                 "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
                 basename(resource),
                 basename(dirname(resource))
             )),
-            primaryButton: ( localize(14306, "&&Replace")),
+            primaryButton: ( localize(14698, "&&Replace"))
         });
         return confirmed;
     }
     async confirmMakeWriteable(resource) {
-        const { confirmed } = await this.dialogService.confirm({
-            type: 'warning',
+        const {
+            confirmed
+        } = await this.dialogService.confirm({
+            type: "warning",
             message: ( localize(
-                14307,
+                14699,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(14308, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(14309, "&&Save Anyway"))
+            detail: ( localize(14700, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(14701, "&&Save Anyway"))
         });
         return confirmed;
     }
@@ -466,15 +526,13 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                 let nameCandidate;
                 if (await this.pathService.hasValidBasename(joinPath(defaultFilePath, model.name), model.name)) {
                     nameCandidate = model.name;
-                }
-                else {
+                } else {
                     nameCandidate = basename(resource);
                 }
                 const languageId = model.getLanguageId();
                 if (languageId && languageId !== PLAINTEXT_LANGUAGE_ID) {
                     suggestedFilename = this.suggestFilename(languageId, nameCandidate);
-                }
-                else {
+                } else {
                     suggestedFilename = nameCandidate;
                 }
             }
@@ -529,30 +587,20 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         return false;
     }
 };
-AbstractTextFileService = AbstractTextFileService_1 = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IUntitledTextEditorService)),
-    ( __param(2, ILifecycleService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IModelService)),
-    ( __param(5, IWorkbenchEnvironmentService)),
-    ( __param(6, IDialogService)),
-    ( __param(7, IFileDialogService)),
-    ( __param(8, ITextResourceConfigurationService)),
-    ( __param(9, IFilesConfigurationService)),
-    ( __param(10, ICodeEditorService)),
-    ( __param(11, IPathService)),
-    ( __param(12, IWorkingCopyFileService)),
-    ( __param(13, IUriIdentityService)),
-    ( __param(14, ILanguageService)),
-    ( __param(15, ILogService)),
-    ( __param(16, IElevatedFileService)),
-    ( __param(17, IDecorationsService))
-], AbstractTextFileService));
+AbstractTextFileService = AbstractTextFileService_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IUntitledTextEditorService)), ( __param(2, ILifecycleService)), ( __param(3, IInstantiationService)), ( __param(4, IModelService)), ( __param(5, IWorkbenchEnvironmentService)), ( __param(6, IDialogService)), ( __param(7, IFileDialogService)), ( __param(8, ITextResourceConfigurationService)), ( __param(9, IFilesConfigurationService)), ( __param(10, ICodeEditorService)), ( __param(11, IPathService)), ( __param(12, IWorkingCopyFileService)), ( __param(13, IUriIdentityService)), ( __param(14, ILanguageService)), ( __param(15, ILogService)), ( __param(16, IElevatedFileService)), ( __param(17, IDecorationsService))], AbstractTextFileService));
 let EncodingOracle = class EncodingOracle extends Disposable {
-    get encodingOverrides() { return this._encodingOverrides; }
-    set encodingOverrides(value) { this._encodingOverrides = value; }
-    constructor(textResourceConfigurationService, environmentService, contextService, uriIdentityService) {
+    get encodingOverrides() {
+        return this._encodingOverrides;
+    }
+    set encodingOverrides(value) {
+        this._encodingOverrides = value;
+    }
+    constructor(
+        textResourceConfigurationService,
+        environmentService,
+        contextService,
+        uriIdentityService
+    ) {
         super();
         this.textResourceConfigurationService = textResourceConfigurationService;
         this.environmentService = environmentService;
@@ -562,21 +610,41 @@ let EncodingOracle = class EncodingOracle extends Disposable {
         this.registerListeners();
     }
     registerListeners() {
-        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.encodingOverrides = this.getDefaultEncodingOverrides()));
+        this._register(
+            this.contextService.onDidChangeWorkspaceFolders(() => this.encodingOverrides = this.getDefaultEncodingOverrides())
+        );
     }
     getDefaultEncodingOverrides() {
         const defaultEncodingOverrides = [];
-        defaultEncodingOverrides.push({ parent: this.environmentService.userRoamingDataHome, encoding: UTF8 });
-        defaultEncodingOverrides.push({ extension: WORKSPACE_EXTENSION, encoding: UTF8 });
-        defaultEncodingOverrides.push({ parent: this.environmentService.untitledWorkspacesHome, encoding: UTF8 });
+        defaultEncodingOverrides.push({
+            parent: this.environmentService.userRoamingDataHome,
+            encoding: UTF8
+        });
+        defaultEncodingOverrides.push({
+            extension: WORKSPACE_EXTENSION,
+            encoding: UTF8
+        });
+        defaultEncodingOverrides.push({
+            parent: this.environmentService.untitledWorkspacesHome,
+            encoding: UTF8
+        });
         this.contextService.getWorkspace().folders.forEach(folder => {
-            defaultEncodingOverrides.push({ parent: joinPath(folder.uri, '.vscode'), encoding: UTF8 });
+            defaultEncodingOverrides.push({
+                parent: joinPath(folder.uri, ".vscode"),
+                encoding: UTF8
+            });
         });
         return defaultEncodingOverrides;
     }
     async getWriteEncoding(resource, options) {
-        const { encoding, hasBOM } = await this.getPreferredWriteEncoding(resource, options ? options.encoding : undefined);
-        return { encoding, addBOM: hasBOM };
+        const {
+            encoding,
+            hasBOM
+        } = await this.getPreferredWriteEncoding(resource, options ? options.encoding : undefined);
+        return {
+            encoding,
+            addBOM: hasBOM
+        };
     }
     async getPreferredWriteEncoding(resource, preferredEncoding) {
         const resourceEncoding = await this.getValidatedEncodingForResource(resource, preferredEncoding);
@@ -590,15 +658,14 @@ let EncodingOracle = class EncodingOracle extends Disposable {
         if (options?.encoding) {
             if (detectedEncoding === UTF8_with_bom && options.encoding === UTF8) {
                 preferredEncoding = UTF8_with_bom;
-            }
-            else {
+            } else {
                 preferredEncoding = options.encoding;
             }
         }
-        else if (typeof detectedEncoding === 'string') {
+        else if (typeof detectedEncoding === "string") {
             preferredEncoding = detectedEncoding;
         }
-        else if (this.textResourceConfigurationService.getValue(resource, 'files.encoding') === UTF8_with_bom) {
+        else if (this.textResourceConfigurationService.getValue(resource, "files.encoding") === UTF8_with_bom) {
             preferredEncoding = UTF8;
         }
         const encoding = await this.getValidatedEncodingForResource(resource, preferredEncoding);
@@ -612,12 +679,10 @@ let EncodingOracle = class EncodingOracle extends Disposable {
         const override = this.getEncodingOverride(resource);
         if (override) {
             fileEncoding = override;
-        }
-        else if (preferredEncoding) {
+        } else if (preferredEncoding) {
             fileEncoding = preferredEncoding;
-        }
-        else {
-            fileEncoding = this.textResourceConfigurationService.getValue(resource, 'files.encoding');
+        } else {
+            fileEncoding = this.textResourceConfigurationService.getValue(resource, "files.encoding");
         }
         return fileEncoding || UTF8;
     }
@@ -642,11 +707,6 @@ let EncodingOracle = class EncodingOracle extends Disposable {
         return undefined;
     }
 };
-EncodingOracle = ( __decorate([
-    ( __param(0, ITextResourceConfigurationService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IUriIdentityService))
-], EncodingOracle));
+EncodingOracle = ( __decorate([( __param(0, ITextResourceConfigurationService)), ( __param(1, IWorkbenchEnvironmentService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IUriIdentityService))], EncodingOracle));
 
 export { AbstractTextFileService, EncodingOracle };