@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

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

@@ -0,0 +1,493 @@
+import { listenStream, newWriteableStream } from '../../../../base/common/stream.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+const UTF8 = 'utf8';
+const UTF8_with_bom = 'utf8bom';
+const UTF16be = 'utf16be';
+const UTF16le = 'utf16le';
+const UTF16be_BOM = [0xFE, 0xFF];
+const UTF16le_BOM = [0xFF, 0xFE];
+const UTF8_BOM = [0xEF, 0xBB, 0xBF];
+const ZERO_BYTE_DETECTION_BUFFER_MAX_LEN = 512;
+const NO_ENCODING_GUESS_MIN_BYTES = 512;
+const AUTO_ENCODING_GUESS_MIN_BYTES = 512 * 8;
+const AUTO_ENCODING_GUESS_MAX_BYTES = 512 * 128;
+class DecodeStreamError extends Error {
+    constructor(message, decodeStreamErrorKind) {
+        super(message);
+        this.decodeStreamErrorKind = decodeStreamErrorKind;
+    }
+}
+class DecoderStream {
+    static async create(encoding) {
+        let decoder = undefined;
+        if (encoding !== UTF8) {
+            const iconv = await import('../../../../../../override/iconv.js').then(module => module.default ?? module);
+            decoder = iconv.getDecoder(toNodeEncoding(encoding));
+        }
+        else {
+            const utf8TextDecoder = ( new TextDecoder());
+            decoder = {
+                write(buffer) {
+                    return utf8TextDecoder.decode(buffer, {
+                        stream: true
+                    });
+                },
+                end() {
+                    return utf8TextDecoder.decode();
+                }
+            };
+        }
+        return ( new DecoderStream(decoder));
+    }
+    constructor(iconvLiteDecoder) {
+        this.iconvLiteDecoder = iconvLiteDecoder;
+    }
+    write(buffer) {
+        return this.iconvLiteDecoder.write(buffer);
+    }
+    end() {
+        return this.iconvLiteDecoder.end();
+    }
+}
+function toDecodeStream(source, options) {
+    const minBytesRequiredForDetection = options.minBytesRequiredForDetection ?? options.guessEncoding ? AUTO_ENCODING_GUESS_MIN_BYTES : NO_ENCODING_GUESS_MIN_BYTES;
+    return ( new Promise((resolve, reject) => {
+        const target = newWriteableStream(strings => strings.join(''));
+        const bufferedChunks = [];
+        let bytesBuffered = 0;
+        let decoder = undefined;
+        const createDecoder = async () => {
+            try {
+                const detected = await detectEncodingFromBuffer({
+                    buffer: VSBuffer.concat(bufferedChunks),
+                    bytesRead: bytesBuffered
+                }, options.guessEncoding);
+                if (detected.seemsBinary && options.acceptTextOnly) {
+                    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);
+                const decoded = decoder.write(VSBuffer.concat(bufferedChunks).buffer);
+                target.write(decoded);
+                bufferedChunks.length = 0;
+                bytesBuffered = 0;
+                resolve({
+                    stream: target,
+                    detected
+                });
+            }
+            catch (error) {
+                sourceListener?.dispose();
+                target.destroy();
+                reject(error);
+            }
+        };
+        const sourceListener = listenStream(source, {
+            onData: async (chunk) => {
+                if (decoder) {
+                    target.write(decoder.write(chunk.buffer));
+                }
+                else {
+                    bufferedChunks.push(chunk);
+                    bytesBuffered += chunk.byteLength;
+                    if (bytesBuffered >= minBytesRequiredForDetection) {
+                        source.pause();
+                        await createDecoder();
+                        setTimeout(() => source.resume());
+                    }
+                }
+            },
+            onError: error => target.error(error),
+            onEnd: async () => {
+                if (!decoder) {
+                    await createDecoder();
+                }
+                target.end(decoder?.end());
+            }
+        });
+    }));
+}
+async function toEncodeReadable(readable, encoding, options) {
+    const iconv = await import('../../../../../../override/iconv.js').then(module => module.default ?? module);
+    const encoder = iconv.getEncoder(toNodeEncoding(encoding), options);
+    let bytesWritten = false;
+    let done = false;
+    return {
+        read() {
+            if (done) {
+                return null;
+            }
+            const chunk = readable.read();
+            if (typeof chunk !== 'string') {
+                done = true;
+                if (!bytesWritten && options?.addBOM) {
+                    switch (encoding) {
+                        case UTF8:
+                        case UTF8_with_bom:
+                            return VSBuffer.wrap(Uint8Array.from(UTF8_BOM));
+                        case UTF16be:
+                            return VSBuffer.wrap(Uint8Array.from(UTF16be_BOM));
+                        case UTF16le:
+                            return VSBuffer.wrap(Uint8Array.from(UTF16le_BOM));
+                    }
+                }
+                const leftovers = encoder.end();
+                if (leftovers && leftovers.length > 0) {
+                    bytesWritten = true;
+                    return VSBuffer.wrap(leftovers);
+                }
+                return null;
+            }
+            bytesWritten = true;
+            return VSBuffer.wrap(encoder.write(chunk));
+        }
+    };
+}
+async function encodingExists(encoding) {
+    const iconv = await import('../../../../../../override/iconv.js').then(module => module.default ?? module);
+    return iconv.encodingExists(toNodeEncoding(encoding));
+}
+function toNodeEncoding(enc) {
+    if (enc === UTF8_with_bom || enc === null) {
+        return UTF8;
+    }
+    return enc;
+}
+function detectEncodingByBOMFromBuffer(buffer, bytesRead) {
+    if (!buffer || bytesRead < UTF16be_BOM.length) {
+        return null;
+    }
+    const b0 = buffer.readUInt8(0);
+    const b1 = buffer.readUInt8(1);
+    if (b0 === UTF16be_BOM[0] && b1 === UTF16be_BOM[1]) {
+        return UTF16be;
+    }
+    if (b0 === UTF16le_BOM[0] && b1 === UTF16le_BOM[1]) {
+        return UTF16le;
+    }
+    if (bytesRead < UTF8_BOM.length) {
+        return null;
+    }
+    const b2 = buffer.readUInt8(2);
+    if (b0 === UTF8_BOM[0] && b1 === UTF8_BOM[1] && b2 === UTF8_BOM[2]) {
+        return UTF8_with_bom;
+    }
+    return null;
+}
+const IGNORE_ENCODINGS = ['ascii', 'utf-16', 'utf-32'];
+async function guessEncodingByBuffer(buffer) {
+    const jschardet = await import('../../../../../../override/jschardet.js').then(module => module.default ?? module);
+    const limitedBuffer = buffer.slice(0, AUTO_ENCODING_GUESS_MAX_BYTES);
+    const binaryString = encodeLatin1(limitedBuffer.buffer);
+    const guessed = jschardet.detect(binaryString);
+    if (!guessed || !guessed.encoding) {
+        return null;
+    }
+    const enc = guessed.encoding.toLowerCase();
+    if (0 <= IGNORE_ENCODINGS.indexOf(enc)) {
+        return null;
+    }
+    return toIconvLiteEncoding(guessed.encoding);
+}
+const JSCHARDET_TO_ICONV_ENCODINGS = {
+    'ibm866': 'cp866',
+    'big5': 'cp950'
+};
+function toIconvLiteEncoding(encodingName) {
+    const normalizedEncodingName = encodingName.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+    const mapped = JSCHARDET_TO_ICONV_ENCODINGS[normalizedEncodingName];
+    return mapped || normalizedEncodingName;
+}
+function encodeLatin1(buffer) {
+    let result = '';
+    for (let i = 0; i < buffer.length; i++) {
+        result += String.fromCharCode(buffer[i]);
+    }
+    return result;
+}
+function detectEncodingFromBuffer({ buffer, bytesRead }, autoGuessEncoding) {
+    let encoding = detectEncodingByBOMFromBuffer(buffer, bytesRead);
+    let seemsBinary = false;
+    if (encoding !== UTF16be && encoding !== UTF16le && buffer) {
+        let couldBeUTF16LE = true;
+        let couldBeUTF16BE = true;
+        let containsZeroByte = false;
+        for (let i = 0; i < bytesRead && i < ZERO_BYTE_DETECTION_BUFFER_MAX_LEN; i++) {
+            const isEndian = (i % 2 === 1);
+            const isZeroByte = (buffer.readUInt8(i) === 0);
+            if (isZeroByte) {
+                containsZeroByte = true;
+            }
+            if (couldBeUTF16LE && (isEndian && !isZeroByte || !isEndian && isZeroByte)) {
+                couldBeUTF16LE = false;
+            }
+            if (couldBeUTF16BE && (isEndian && isZeroByte || !isEndian && !isZeroByte)) {
+                couldBeUTF16BE = false;
+            }
+            if (isZeroByte && !couldBeUTF16LE && !couldBeUTF16BE) {
+                break;
+            }
+        }
+        if (containsZeroByte) {
+            if (couldBeUTF16LE) {
+                encoding = UTF16le;
+            }
+            else if (couldBeUTF16BE) {
+                encoding = UTF16be;
+            }
+            else {
+                seemsBinary = true;
+            }
+        }
+    }
+    if (autoGuessEncoding && !seemsBinary && !encoding && buffer) {
+        return guessEncodingByBuffer(buffer.slice(0, bytesRead)).then(guessedEncoding => {
+            return {
+                seemsBinary: false,
+                encoding: guessedEncoding
+            };
+        });
+    }
+    return { seemsBinary, encoding };
+}
+const SUPPORTED_ENCODINGS = {
+    utf8: {
+        labelLong: 'UTF-8',
+        labelShort: 'UTF-8',
+        order: 1,
+        alias: 'utf8bom'
+    },
+    utf8bom: {
+        labelLong: 'UTF-8 with BOM',
+        labelShort: 'UTF-8 with BOM',
+        encodeOnly: true,
+        order: 2,
+        alias: 'utf8'
+    },
+    utf16le: {
+        labelLong: 'UTF-16 LE',
+        labelShort: 'UTF-16 LE',
+        order: 3
+    },
+    utf16be: {
+        labelLong: 'UTF-16 BE',
+        labelShort: 'UTF-16 BE',
+        order: 4
+    },
+    windows1252: {
+        labelLong: 'Western (Windows 1252)',
+        labelShort: 'Windows 1252',
+        order: 5
+    },
+    iso88591: {
+        labelLong: 'Western (ISO 8859-1)',
+        labelShort: 'ISO 8859-1',
+        order: 6
+    },
+    iso88593: {
+        labelLong: 'Western (ISO 8859-3)',
+        labelShort: 'ISO 8859-3',
+        order: 7
+    },
+    iso885915: {
+        labelLong: 'Western (ISO 8859-15)',
+        labelShort: 'ISO 8859-15',
+        order: 8
+    },
+    macroman: {
+        labelLong: 'Western (Mac Roman)',
+        labelShort: 'Mac Roman',
+        order: 9
+    },
+    cp437: {
+        labelLong: 'DOS (CP 437)',
+        labelShort: 'CP437',
+        order: 10
+    },
+    windows1256: {
+        labelLong: 'Arabic (Windows 1256)',
+        labelShort: 'Windows 1256',
+        order: 11
+    },
+    iso88596: {
+        labelLong: 'Arabic (ISO 8859-6)',
+        labelShort: 'ISO 8859-6',
+        order: 12
+    },
+    windows1257: {
+        labelLong: 'Baltic (Windows 1257)',
+        labelShort: 'Windows 1257',
+        order: 13
+    },
+    iso88594: {
+        labelLong: 'Baltic (ISO 8859-4)',
+        labelShort: 'ISO 8859-4',
+        order: 14
+    },
+    iso885914: {
+        labelLong: 'Celtic (ISO 8859-14)',
+        labelShort: 'ISO 8859-14',
+        order: 15
+    },
+    windows1250: {
+        labelLong: 'Central European (Windows 1250)',
+        labelShort: 'Windows 1250',
+        order: 16
+    },
+    iso88592: {
+        labelLong: 'Central European (ISO 8859-2)',
+        labelShort: 'ISO 8859-2',
+        order: 17
+    },
+    cp852: {
+        labelLong: 'Central European (CP 852)',
+        labelShort: 'CP 852',
+        order: 18
+    },
+    windows1251: {
+        labelLong: 'Cyrillic (Windows 1251)',
+        labelShort: 'Windows 1251',
+        order: 19
+    },
+    cp866: {
+        labelLong: 'Cyrillic (CP 866)',
+        labelShort: 'CP 866',
+        order: 20
+    },
+    iso88595: {
+        labelLong: 'Cyrillic (ISO 8859-5)',
+        labelShort: 'ISO 8859-5',
+        order: 21
+    },
+    koi8r: {
+        labelLong: 'Cyrillic (KOI8-R)',
+        labelShort: 'KOI8-R',
+        order: 22
+    },
+    koi8u: {
+        labelLong: 'Cyrillic (KOI8-U)',
+        labelShort: 'KOI8-U',
+        order: 23
+    },
+    iso885913: {
+        labelLong: 'Estonian (ISO 8859-13)',
+        labelShort: 'ISO 8859-13',
+        order: 24
+    },
+    windows1253: {
+        labelLong: 'Greek (Windows 1253)',
+        labelShort: 'Windows 1253',
+        order: 25
+    },
+    iso88597: {
+        labelLong: 'Greek (ISO 8859-7)',
+        labelShort: 'ISO 8859-7',
+        order: 26
+    },
+    windows1255: {
+        labelLong: 'Hebrew (Windows 1255)',
+        labelShort: 'Windows 1255',
+        order: 27
+    },
+    iso88598: {
+        labelLong: 'Hebrew (ISO 8859-8)',
+        labelShort: 'ISO 8859-8',
+        order: 28
+    },
+    iso885910: {
+        labelLong: 'Nordic (ISO 8859-10)',
+        labelShort: 'ISO 8859-10',
+        order: 29
+    },
+    iso885916: {
+        labelLong: 'Romanian (ISO 8859-16)',
+        labelShort: 'ISO 8859-16',
+        order: 30
+    },
+    windows1254: {
+        labelLong: 'Turkish (Windows 1254)',
+        labelShort: 'Windows 1254',
+        order: 31
+    },
+    iso88599: {
+        labelLong: 'Turkish (ISO 8859-9)',
+        labelShort: 'ISO 8859-9',
+        order: 32
+    },
+    windows1258: {
+        labelLong: 'Vietnamese (Windows 1258)',
+        labelShort: 'Windows 1258',
+        order: 33
+    },
+    gbk: {
+        labelLong: 'Simplified Chinese (GBK)',
+        labelShort: 'GBK',
+        order: 34
+    },
+    gb18030: {
+        labelLong: 'Simplified Chinese (GB18030)',
+        labelShort: 'GB18030',
+        order: 35
+    },
+    cp950: {
+        labelLong: 'Traditional Chinese (Big5)',
+        labelShort: 'Big5',
+        order: 36
+    },
+    big5hkscs: {
+        labelLong: 'Traditional Chinese (Big5-HKSCS)',
+        labelShort: 'Big5-HKSCS',
+        order: 37
+    },
+    shiftjis: {
+        labelLong: 'Japanese (Shift JIS)',
+        labelShort: 'Shift JIS',
+        order: 38
+    },
+    eucjp: {
+        labelLong: 'Japanese (EUC-JP)',
+        labelShort: 'EUC-JP',
+        order: 39
+    },
+    euckr: {
+        labelLong: 'Korean (EUC-KR)',
+        labelShort: 'EUC-KR',
+        order: 40
+    },
+    windows874: {
+        labelLong: 'Thai (Windows 874)',
+        labelShort: 'Windows 874',
+        order: 41
+    },
+    iso885911: {
+        labelLong: 'Latin/Thai (ISO 8859-11)',
+        labelShort: 'ISO 8859-11',
+        order: 42
+    },
+    koi8ru: {
+        labelLong: 'Cyrillic (KOI8-RU)',
+        labelShort: 'KOI8-RU',
+        order: 43
+    },
+    koi8t: {
+        labelLong: 'Tajik (KOI8-T)',
+        labelShort: 'KOI8-T',
+        order: 44
+    },
+    gb2312: {
+        labelLong: 'Simplified Chinese (GB 2312)',
+        labelShort: 'GB 2312',
+        order: 45
+    },
+    cp865: {
+        labelLong: 'Nordic DOS (CP 865)',
+        labelShort: 'CP 865',
+        order: 46
+    },
+    cp850: {
+        labelLong: 'Western European DOS (CP 850)',
+        labelShort: 'CP 850',
+        order: 47
+    }
+};
+export { DecodeStreamError, SUPPORTED_ENCODINGS, UTF16be, UTF16be_BOM, UTF16le, UTF16le_BOM, UTF8, UTF8_BOM, UTF8_with_bom, detectEncodingByBOMFromBuffer, detectEncodingFromBuffer, encodingExists, toDecodeStream, toEncodeReadable, toNodeEncoding };

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

@@ -0,0 +1,150 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { EditorExtensions, DEFAULT_EDITOR_ASSOCIATION, isResourceMergeEditorInput, isResourceDiffEditorInput, isResourceSideBySideEditorInput } from '../../../common/editor.js';
+import { IUntitledTextEditorService } from '../../untitled/common/untitledTextEditorService.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
+import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { TextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
+import { UntitledTextEditorInput } from '../../untitled/common/untitledTextEditorInput.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../editor/common/editorResolverService.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const ITextEditorService = ( createDecorator('textEditorService'));
+let TextEditorService = class TextEditorService extends Disposable {
+    constructor(untitledTextEditorService, instantiationService, uriIdentityService, fileService, editorResolverService) {
+        super();
+        this.untitledTextEditorService = untitledTextEditorService;
+        this.instantiationService = instantiationService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileService = fileService;
+        this.editorResolverService = editorResolverService;
+        this.editorInputCache = ( new ResourceMap());
+        this.fileEditorFactory = ( Registry.as(EditorExtensions.EditorFactory)).getFileEditorFactory();
+        this.registerDefaultEditor();
+    }
+    registerDefaultEditor() {
+        this._register(this.editorResolverService.registerEditor('*', {
+            id: DEFAULT_EDITOR_ASSOCIATION.id,
+            label: DEFAULT_EDITOR_ASSOCIATION.displayName,
+            detail: DEFAULT_EDITOR_ASSOCIATION.providerDisplayName,
+            priority: RegisteredEditorPriority.builtin
+        }, {}, {
+            createEditorInput: editor => ({ editor: this.createTextEditor(editor) }),
+            createUntitledEditorInput: untitledEditor => ({ editor: this.createTextEditor(untitledEditor) }),
+            createDiffEditorInput: diffEditor => ({ editor: this.createTextEditor(diffEditor) })
+        }));
+    }
+    async resolveTextEditor(input) {
+        return this.createTextEditor(input);
+    }
+    createTextEditor(input) {
+        if (isResourceMergeEditorInput(input)) {
+            return this.createTextEditor(input.result);
+        }
+        if (isResourceDiffEditorInput(input)) {
+            const original = this.createTextEditor(input.original);
+            const modified = this.createTextEditor(input.modified);
+            return this.instantiationService.createInstance(DiffEditorInput, input.label, input.description, original, modified, undefined);
+        }
+        if (isResourceSideBySideEditorInput(input)) {
+            const primary = this.createTextEditor(input.primary);
+            const secondary = this.createTextEditor(input.secondary);
+            return this.instantiationService.createInstance(SideBySideEditorInput, input.label, input.description, secondary, primary);
+        }
+        const untitledInput = input;
+        if (untitledInput.forceUntitled || !untitledInput.resource || (untitledInput.resource.scheme === Schemas.untitled)) {
+            const untitledOptions = {
+                languageId: untitledInput.languageId,
+                initialValue: untitledInput.contents,
+                encoding: untitledInput.encoding
+            };
+            let untitledModel;
+            if (untitledInput.resource?.scheme === Schemas.untitled) {
+                untitledModel = this.untitledTextEditorService.create({ untitledResource: untitledInput.resource, ...untitledOptions });
+            }
+            else {
+                untitledModel = this.untitledTextEditorService.create({ associatedResource: untitledInput.resource, ...untitledOptions });
+            }
+            return this.createOrGetCached(untitledModel.resource, () => {
+                const input = this.instantiationService.createInstance(UntitledTextEditorInput, untitledModel);
+                Event.once(input.onWillDispose)(() => untitledModel.dispose());
+                return input;
+            });
+        }
+        const textResourceEditorInput = input;
+        if (textResourceEditorInput.resource instanceof URI) {
+            const label = textResourceEditorInput.label || basename(textResourceEditorInput.resource);
+            const preferredResource = textResourceEditorInput.resource;
+            const canonicalResource = this.uriIdentityService.asCanonicalUri(preferredResource);
+            return this.createOrGetCached(canonicalResource, () => {
+                if (textResourceEditorInput.forceFile || this.fileService.hasProvider(canonicalResource)) {
+                    return this.fileEditorFactory.createFileEditor(canonicalResource, preferredResource, textResourceEditorInput.label, textResourceEditorInput.description, textResourceEditorInput.encoding, textResourceEditorInput.languageId, textResourceEditorInput.contents, this.instantiationService);
+                }
+                return this.instantiationService.createInstance(TextResourceEditorInput, canonicalResource, textResourceEditorInput.label, textResourceEditorInput.description, textResourceEditorInput.languageId, textResourceEditorInput.contents);
+            }, cachedInput => {
+                if (cachedInput instanceof UntitledTextEditorInput) {
+                    return;
+                }
+                else if (!(cachedInput instanceof TextResourceEditorInput)) {
+                    cachedInput.setPreferredResource(preferredResource);
+                    if (textResourceEditorInput.label) {
+                        cachedInput.setPreferredName(textResourceEditorInput.label);
+                    }
+                    if (textResourceEditorInput.description) {
+                        cachedInput.setPreferredDescription(textResourceEditorInput.description);
+                    }
+                    if (textResourceEditorInput.encoding) {
+                        cachedInput.setPreferredEncoding(textResourceEditorInput.encoding);
+                    }
+                    if (textResourceEditorInput.languageId) {
+                        cachedInput.setPreferredLanguageId(textResourceEditorInput.languageId);
+                    }
+                    if (typeof textResourceEditorInput.contents === 'string') {
+                        cachedInput.setPreferredContents(textResourceEditorInput.contents);
+                    }
+                }
+                else {
+                    if (label) {
+                        cachedInput.setName(label);
+                    }
+                    if (textResourceEditorInput.description) {
+                        cachedInput.setDescription(textResourceEditorInput.description);
+                    }
+                    if (textResourceEditorInput.languageId) {
+                        cachedInput.setPreferredLanguageId(textResourceEditorInput.languageId);
+                    }
+                    if (typeof textResourceEditorInput.contents === 'string') {
+                        cachedInput.setPreferredContents(textResourceEditorInput.contents);
+                    }
+                }
+            });
+        }
+        throw new Error(`ITextEditorService: Unable to create texteditor from ${JSON.stringify(input)}`);
+    }
+    createOrGetCached(resource, factoryFn, cachedFn) {
+        let input = this.editorInputCache.get(resource);
+        if (input) {
+            cachedFn?.(input);
+            return input;
+        }
+        input = factoryFn();
+        this.editorInputCache.set(resource, input);
+        Event.once(input.onWillDispose)(() => this.editorInputCache.delete(resource));
+        return input;
+    }
+};
+TextEditorService = ( __decorate([
+    ( __param(0, IUntitledTextEditorService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IEditorResolverService))
+], TextEditorService));
+export { ITextEditorService, TextEditorService };