@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

package/vscode/src/vs/platform/files/common/files.js

@@ -1,81 +0,0 @@
-import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-var FileType;
-( (function(FileType) {
-    FileType[FileType["Unknown"] = 0] = "Unknown";
-    FileType[FileType["File"] = 1] = "File";
-    FileType[FileType["Directory"] = 2] = "Directory";
-    FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
-})(FileType || (FileType = {})));
-var FilePermission;
-( (function(FilePermission) {
-    FilePermission[FilePermission["Readonly"] = 1] = "Readonly";
-    FilePermission[FilePermission["Locked"] = 2] = "Locked";
-})(FilePermission || (FilePermission = {})));
-var FileSystemProviderCapabilities;
-( (function(FileSystemProviderCapabilities) {
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["None"] = 0] = "None";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadWrite"] = 2] = "FileReadWrite";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileOpenReadWriteClose"] = 4] = "FileOpenReadWriteClose";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadStream"] = 16] = "FileReadStream";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileFolderCopy"] = 8] = "FileFolderCopy";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["PathCaseSensitive"] = 1024] = "PathCaseSensitive";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["Readonly"] = 2048] = "Readonly";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["Trash"] = 4096] = "Trash";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileWriteUnlock"] = 8192] = "FileWriteUnlock";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicRead"] = 16384] = "FileAtomicRead";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicWrite"] = 32768] = "FileAtomicWrite";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicDelete"] = 65536] = "FileAtomicDelete";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileClone"] = 131072] = "FileClone";
-})(FileSystemProviderCapabilities || (FileSystemProviderCapabilities = {})));
-var FileChangeType;
-( (function(FileChangeType) {
-    FileChangeType[FileChangeType["UPDATED"] = 0] = "UPDATED";
-    FileChangeType[FileChangeType["ADDED"] = 1] = "ADDED";
-    FileChangeType[FileChangeType["DELETED"] = 2] = "DELETED";
-})(FileChangeType || (FileChangeType = {})));
-class ByteSize {
-    static { this.KB = 1024; }
-    static { this.MB = ByteSize.KB * ByteSize.KB; }
-    static { this.GB = ByteSize.MB * ByteSize.KB; }
-    static { this.TB = ByteSize.GB * ByteSize.KB; }
-    static formatSize(size) {
-        if (!isNumber(size)) {
-            size = 0;
-        }
-        if (size < ByteSize.KB) {
-            return ( localizeWithPath('vs/platform/files/common/files', 'sizeB', "{0}B", size.toFixed(0)));
-        }
-        if (size < ByteSize.MB) {
-            return ( localizeWithPath(
-                'vs/platform/files/common/files',
-                'sizeKB',
-                "{0}KB",
-                (size / ByteSize.KB).toFixed(2)
-            ));
-        }
-        if (size < ByteSize.GB) {
-            return ( localizeWithPath(
-                'vs/platform/files/common/files',
-                'sizeMB',
-                "{0}MB",
-                (size / ByteSize.MB).toFixed(2)
-            ));
-        }
-        if (size < ByteSize.TB) {
-            return ( localizeWithPath(
-                'vs/platform/files/common/files',
-                'sizeGB',
-                "{0}GB",
-                (size / ByteSize.GB).toFixed(2)
-            ));
-        }
-        return ( localizeWithPath(
-            'vs/platform/files/common/files',
-            'sizeTB',
-            "{0}TB",
-            (size / ByteSize.TB).toFixed(2)
-        ));
-    }
-}
-export { ByteSize, FileChangeType, FilePermission, FileSystemProviderCapabilities, FileType };

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js

@@ -1,220 +0,0 @@
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import { newWriteableStream } from 'monaco-editor/esm/vs/base/common/stream.js';
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-class File {
-    constructor(name) {
-        this.type = FileType.File;
-        this.ctime = Date.now();
-        this.mtime = Date.now();
-        this.size = 0;
-        this.name = name;
-    }
-}
-class Directory {
-    constructor(name) {
-        this.type = FileType.Directory;
-        this.ctime = Date.now();
-        this.mtime = Date.now();
-        this.size = 0;
-        this.name = name;
-        this.entries = ( new Map());
-    }
-}
-class InMemoryFileSystemProvider extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.memoryFdCounter = 0;
-        this.fdMemory = ( new Map());
-        this._onDidChangeCapabilities = this._register(( new Emitter()));
-        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
-        this._capabilities = 2  | 1024 ;
-        this.root = ( new Directory(''));
-        this._onDidChangeFile = this._register(( new Emitter()));
-        this.onDidChangeFile = this._onDidChangeFile.event;
-        this._bufferedChanges = [];
-    }
-    get capabilities() { return this._capabilities; }
-    setReadOnly(readonly) {
-        const isReadonly = !!((this._capabilities & 2048) );
-        if (readonly !== isReadonly) {
-            this._capabilities = readonly ? 2048  | 1024  | 2
-                : 2  | 1024 ;
-            this._onDidChangeCapabilities.fire();
-        }
-    }
-    async stat(resource) {
-        return this._lookup(resource, false);
-    }
-    async readdir(resource) {
-        const entry = this._lookupAsDirectory(resource, false);
-        const result = [];
-        entry.entries.forEach((child, name) => result.push([name, child.type]));
-        return result;
-    }
-    async readFile(resource) {
-        const data = this._lookupAsFile(resource, false).data;
-        if (data) {
-            return data;
-        }
-        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    readFileStream(resource) {
-        const data = this._lookupAsFile(resource, false).data;
-        const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
-        stream.end(data);
-        return stream;
-    }
-    async writeFile(resource, content, opts) {
-        const basename = resources.basename(resource);
-        const parent = this._lookupParentDirectory(resource);
-        let entry = parent.entries.get(basename);
-        if (entry instanceof Directory) {
-            throw createFileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
-        }
-        if (!entry && !opts.create) {
-            throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-        }
-        if (entry && opts.create && !opts.overwrite) {
-            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
-        }
-        if (!entry) {
-            entry = ( new File(basename));
-            parent.entries.set(basename, entry);
-            this._fireSoon({ type: 1 , resource });
-        }
-        entry.mtime = Date.now();
-        entry.size = content.byteLength;
-        entry.data = content;
-        this._fireSoon({ type: 0 , resource });
-    }
-    open(resource, opts) {
-        const data = this._lookupAsFile(resource, false).data;
-        if (data) {
-            const fd = this.memoryFdCounter++;
-            this.fdMemory.set(fd, data);
-            return Promise.resolve(fd);
-        }
-        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    close(fd) {
-        this.fdMemory.delete(fd);
-        return Promise.resolve();
-    }
-    read(fd, pos, data, offset, length) {
-        const memory = this.fdMemory.get(fd);
-        if (!memory) {
-            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
-        }
-        const toWrite = VSBuffer.wrap(memory).slice(pos, pos + length);
-        data.set(toWrite.buffer, offset);
-        return Promise.resolve(toWrite.byteLength);
-    }
-    write(fd, pos, data, offset, length) {
-        const memory = this.fdMemory.get(fd);
-        if (!memory) {
-            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
-        }
-        const toWrite = VSBuffer.wrap(data).slice(offset, offset + length);
-        memory.set(toWrite.buffer, pos);
-        return Promise.resolve(toWrite.byteLength);
-    }
-    async rename(from, to, opts) {
-        if (!opts.overwrite && this._lookup(to, true)) {
-            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
-        }
-        const entry = this._lookup(from, false);
-        const oldParent = this._lookupParentDirectory(from);
-        const newParent = this._lookupParentDirectory(to);
-        const newName = resources.basename(to);
-        oldParent.entries.delete(entry.name);
-        entry.name = newName;
-        newParent.entries.set(newName, entry);
-        this._fireSoon({ type: 2 , resource: from }, { type: 1 , resource: to });
-    }
-    async delete(resource, opts) {
-        const dirname = resources.dirname(resource);
-        const basename = resources.basename(resource);
-        const parent = this._lookupAsDirectory(dirname, false);
-        if (( parent.entries.has(basename))) {
-            parent.entries.delete(basename);
-            parent.mtime = Date.now();
-            parent.size -= 1;
-            this._fireSoon({ type: 0 , resource: dirname }, { resource, type: 2  });
-        }
-    }
-    async mkdir(resource) {
-        if (this._lookup(resource, true)) {
-            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
-        }
-        const basename = resources.basename(resource);
-        const dirname = resources.dirname(resource);
-        const parent = this._lookupAsDirectory(dirname, false);
-        const entry = ( new Directory(basename));
-        parent.entries.set(entry.name, entry);
-        parent.mtime = Date.now();
-        parent.size += 1;
-        this._fireSoon({ type: 0 , resource: dirname }, { type: 1 , resource });
-    }
-    _lookup(uri, silent) {
-        const parts = uri.path.split('/');
-        let entry = this.root;
-        for (const part of parts) {
-            if (!part) {
-                continue;
-            }
-            let child;
-            if (entry instanceof Directory) {
-                child = entry.entries.get(part);
-            }
-            if (!child) {
-                if (!silent) {
-                    throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-                }
-                else {
-                    return undefined;
-                }
-            }
-            entry = child;
-        }
-        return entry;
-    }
-    _lookupAsDirectory(uri, silent) {
-        const entry = this._lookup(uri, silent);
-        if (entry instanceof Directory) {
-            return entry;
-        }
-        throw createFileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
-    }
-    _lookupAsFile(uri, silent) {
-        const entry = this._lookup(uri, silent);
-        if (entry instanceof File) {
-            return entry;
-        }
-        throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
-    }
-    _lookupParentDirectory(uri) {
-        const dirname = resources.dirname(uri);
-        return this._lookupAsDirectory(dirname, false);
-    }
-    watch(resource, opts) {
-        return Disposable.None;
-    }
-    _fireSoon(...changes) {
-        this._bufferedChanges.push(...changes);
-        if (this._fireSoonHandle) {
-            clearTimeout(this._fireSoonHandle);
-        }
-        this._fireSoonHandle = setTimeout(() => {
-            this._onDidChangeFile.fire(this._bufferedChanges);
-            this._bufferedChanges.length = 0;
-        }, 5);
-    }
-    dispose() {
-        super.dispose();
-        this.fdMemory.clear();
-    }
-}
-export { InMemoryFileSystemProvider };

package/vscode/src/vs/platform/files/common/io.js

@@ -1,75 +0,0 @@
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { ensureFileSystemProviderError, createFileSystemProviderError, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-async function readFileIntoStream(provider, resource, target, transformer, options, token) {
-    let error = undefined;
-    try {
-        await doReadFileIntoStream(provider, resource, target, transformer, options, token);
-    }
-    catch (err) {
-        error = err;
-    }
-    finally {
-        if (error && options.errorTransformer) {
-            error = options.errorTransformer(error);
-        }
-        if (typeof error !== 'undefined') {
-            target.error(error);
-        }
-        target.end();
-    }
-}
-async function doReadFileIntoStream(provider, resource, target, transformer, options, token) {
-    throwIfCancelled(token);
-    const handle = await provider.open(resource, { create: false });
-    try {
-        throwIfCancelled(token);
-        let totalBytesRead = 0;
-        let bytesRead = 0;
-        let allowedRemainingBytes = (options && typeof options.length === 'number') ? options.length : undefined;
-        let buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
-        let posInFile = options && typeof options.position === 'number' ? options.position : 0;
-        let posInBuffer = 0;
-        do {
-            bytesRead = await provider.read(handle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
-            posInFile += bytesRead;
-            posInBuffer += bytesRead;
-            totalBytesRead += bytesRead;
-            if (typeof allowedRemainingBytes === 'number') {
-                allowedRemainingBytes -= bytesRead;
-            }
-            if (posInBuffer === buffer.byteLength) {
-                await target.write(transformer(buffer));
-                buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
-                posInBuffer = 0;
-            }
-        } while (bytesRead > 0 && (typeof allowedRemainingBytes !== 'number' || allowedRemainingBytes > 0) && throwIfCancelled(token) && throwIfTooLarge(totalBytesRead, options));
-        if (posInBuffer > 0) {
-            let lastChunkLength = posInBuffer;
-            if (typeof allowedRemainingBytes === 'number') {
-                lastChunkLength = Math.min(posInBuffer, allowedRemainingBytes);
-            }
-            target.write(transformer(buffer.slice(0, lastChunkLength)));
-        }
-    }
-    catch (error) {
-        throw ensureFileSystemProviderError(error);
-    }
-    finally {
-        await provider.close(handle);
-    }
-}
-function throwIfCancelled(token) {
-    if (token.isCancellationRequested) {
-        throw canceled();
-    }
-    return true;
-}
-function throwIfTooLarge(totalBytesRead, options) {
-    if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
-        throw createFileSystemProviderError(localizeWithPath('vs/platform/files/common/io', 'fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
-    }
-    return true;
-}
-export { readFileIntoStream };

package/vscode/src/vs/platform/files/common/watcher.js

@@ -1,69 +0,0 @@
-import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
-import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
-class AbstractWatcherClient extends Disposable {
-    static { this.MAX_RESTARTS = 5; }
-    constructor(onFileChanges, onLogMessage, verboseLogging, options) {
-        super();
-        this.onFileChanges = onFileChanges;
-        this.onLogMessage = onLogMessage;
-        this.verboseLogging = verboseLogging;
-        this.options = options;
-        this.watcherDisposables = this._register(( new MutableDisposable()));
-        this.requests = undefined;
-        this.restartCounter = 0;
-    }
-    init() {
-        const disposables = ( new DisposableStore());
-        this.watcherDisposables.value = disposables;
-        this.watcher = this.createWatcher(disposables);
-        this.watcher.setVerboseLogging(this.verboseLogging);
-        disposables.add(this.watcher.onDidChangeFile(changes => this.onFileChanges(changes)));
-        disposables.add(this.watcher.onDidLogMessage(msg => this.onLogMessage(msg)));
-        disposables.add(this.watcher.onDidError(error => this.onError(error)));
-    }
-    onError(error) {
-        if (this.options.restartOnError) {
-            if (this.restartCounter < AbstractWatcherClient.MAX_RESTARTS && this.requests) {
-                this.error(`restarting watcher after error: ${error}`);
-                this.restart(this.requests);
-            }
-            else {
-                this.error(`gave up attempting to restart watcher after error: ${error}`);
-            }
-        }
-        else {
-            this.error(error);
-        }
-    }
-    restart(requests) {
-        this.restartCounter++;
-        this.init();
-        this.watch(requests);
-    }
-    async watch(requests) {
-        this.requests = requests;
-        await this.watcher?.watch(requests);
-    }
-    async setVerboseLogging(verboseLogging) {
-        this.verboseLogging = verboseLogging;
-        await this.watcher?.setVerboseLogging(verboseLogging);
-    }
-    error(message) {
-        this.onLogMessage({ type: 'error', message: `[File Watcher (${this.options.type})] ${message}` });
-    }
-    trace(message) {
-        this.onLogMessage({ type: 'trace', message: `[File Watcher (${this.options.type})] ${message}` });
-    }
-    dispose() {
-        this.watcher = undefined;
-        return super.dispose();
-    }
-}
-function normalizeWatcherPattern(path, pattern) {
-    if (typeof pattern === 'string' && !pattern.startsWith(GLOBSTAR) && !isAbsolute(pattern)) {
-        return { base: path, pattern };
-    }
-    return pattern;
-}
-export { AbstractWatcherClient, normalizeWatcherPattern };

package/vscode/src/vs/platform/keyboardLayout/common/keyboardConfig.js

@@ -1,48 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-function readKeyboardConfig(configurationService) {
-    const keyboard = configurationService.getValue('keyboard');
-    const dispatch = ((keyboard?.dispatch === 'keyCode' ? 1  : 0) );
-    const mapAltGrToCtrlAlt = Boolean(keyboard?.mapAltGrToCtrlAlt);
-    return { dispatch, mapAltGrToCtrlAlt };
-}
-const configurationRegistry = ( Registry.as(Extensions.Configuration));
-const keyboardConfiguration = {
-    'id': 'keyboard',
-    'order': 15,
-    'type': 'object',
-    'title': ( nls.localizeWithPath(
-        'vs/platform/keyboardLayout/common/keyboardConfig',
-        'keyboardConfigurationTitle',
-        "Keyboard"
-    )),
-    'properties': {
-        'keyboard.dispatch': {
-            scope: 1 ,
-            type: 'string',
-            enum: ['code', 'keyCode'],
-            default: 'code',
-            markdownDescription: ( nls.localizeWithPath(
-                'vs/platform/keyboardLayout/common/keyboardConfig',
-                'dispatch',
-                "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."
-            )),
-            included: OS === 2  || OS === 3
-        },
-        'keyboard.mapAltGrToCtrlAlt': {
-            scope: 1 ,
-            type: 'boolean',
-            default: false,
-            markdownDescription: ( nls.localizeWithPath(
-                'vs/platform/keyboardLayout/common/keyboardConfig',
-                'mapAltGrToCtrlAlt',
-                "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+."
-            )),
-            included: OS === 1
-        }
-    }
-};
-configurationRegistry.registerConfiguration(keyboardConfiguration);
-export { readKeyboardConfig };

package/vscode/src/vs/platform/keyboardLayout/common/keyboardMapper.js

@@ -1,23 +0,0 @@
-class CachedKeyboardMapper {
-    constructor(actual) {
-        this._actual = actual;
-        this._cache = ( new Map());
-    }
-    dumpDebugInfo() {
-        return this._actual.dumpDebugInfo();
-    }
-    resolveKeyboardEvent(keyboardEvent) {
-        return this._actual.resolveKeyboardEvent(keyboardEvent);
-    }
-    resolveKeybinding(keybinding) {
-        const hashCode = keybinding.getHashCode();
-        const resolved = this._cache.get(hashCode);
-        if (!resolved) {
-            const r = this._actual.resolveKeybinding(keybinding);
-            this._cache.set(hashCode, r);
-            return r;
-        }
-        return resolved;
-    }
-}
-export { CachedKeyboardMapper };

package/vscode/src/vs/platform/lifecycle/common/lifecycle.js

@@ -1,25 +0,0 @@
-import { isThenable, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-function handleVetos(vetos, onError) {
-    if (vetos.length === 0) {
-        return Promise.resolve(false);
-    }
-    const promises = [];
-    let lazyValue = false;
-    for (const valueOrPromise of vetos) {
-        if (valueOrPromise === true) {
-            return Promise.resolve(true);
-        }
-        if (isThenable(valueOrPromise)) {
-            promises.push(valueOrPromise.then(value => {
-                if (value) {
-                    lazyValue = true;
-                }
-            }, err => {
-                onError(err);
-                lazyValue = true;
-            }));
-        }
-    }
-    return Promises.settled(promises).then(() => lazyValue);
-}
-export { handleVetos };

package/vscode/src/vs/platform/log/common/fileLog.js

@@ -1,105 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { joinPath, dirname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { whenProviderRegistered, IFileService, ByteSize } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { BufferLogger } from './bufferLog.js';
-import { AbstractLoggerService, AbstractMessageLogger, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-const MAX_FILE_SIZE = 5 * ByteSize.MB;
-let FileLogger = class FileLogger extends AbstractMessageLogger {
-    constructor(resource, level, donotUseFormatters, fileService) {
-        super();
-        this.resource = resource;
-        this.donotUseFormatters = donotUseFormatters;
-        this.fileService = fileService;
-        this.backupIndex = 1;
-        this.buffer = '';
-        this.setLevel(level);
-        this.flushDelayer = ( new ThrottledDelayer(100 ));
-        this.initializePromise = this.initialize();
-    }
-    async flush() {
-        if (!this.buffer) {
-            return;
-        }
-        await this.initializePromise;
-        let content = await this.loadContent();
-        if (content.length > MAX_FILE_SIZE) {
-            await this.fileService.writeFile(this.getBackupResource(), VSBuffer.fromString(content));
-            content = '';
-        }
-        if (this.buffer) {
-            content += this.buffer;
-            this.buffer = '';
-            await this.fileService.writeFile(this.resource, VSBuffer.fromString(content));
-        }
-    }
-    async initialize() {
-        try {
-            await this.fileService.createFile(this.resource);
-        }
-        catch (error) {
-            if (error.fileOperationResult !== 3 ) {
-                throw error;
-            }
-        }
-    }
-    log(level, message) {
-        if (this.donotUseFormatters) {
-            this.buffer += message;
-        }
-        else {
-            this.buffer += `${this.getCurrentTimestamp()} [${this.stringifyLogLevel(level)}] ${message}\n`;
-        }
-        this.flushDelayer.trigger(() => this.flush());
-    }
-    getCurrentTimestamp() {
-        const toTwoDigits = (v) => v < 10 ? `0${v}` : v;
-        const toThreeDigits = (v) => v < 10 ? `00${v}` : v < 100 ? `0${v}` : v;
-        const currentTime = ( new Date());
-        return `${currentTime.getFullYear()}-${toTwoDigits(currentTime.getMonth() + 1)}-${toTwoDigits(currentTime.getDate())} ${toTwoDigits(currentTime.getHours())}:${toTwoDigits(currentTime.getMinutes())}:${toTwoDigits(currentTime.getSeconds())}.${toThreeDigits(currentTime.getMilliseconds())}`;
-    }
-    getBackupResource() {
-        this.backupIndex = this.backupIndex > 5 ? 1 : this.backupIndex;
-        return joinPath(dirname(this.resource), `${basename(this.resource)}_${this.backupIndex++}`);
-    }
-    async loadContent() {
-        try {
-            const content = await this.fileService.readFile(this.resource);
-            return ( content.value.toString());
-        }
-        catch (e) {
-            return '';
-        }
-    }
-    stringifyLogLevel(level) {
-        switch (level) {
-            case LogLevel.Debug: return 'debug';
-            case LogLevel.Error: return 'error';
-            case LogLevel.Info: return 'info';
-            case LogLevel.Trace: return 'trace';
-            case LogLevel.Warning: return 'warning';
-        }
-        return '';
-    }
-};
-FileLogger = ( __decorate([
-    ( __param(3, IFileService))
-], FileLogger));
-class FileLoggerService extends AbstractLoggerService {
-    constructor(logLevel, logsHome, fileService) {
-        super(logLevel, logsHome);
-        this.fileService = fileService;
-    }
-    doCreateLogger(resource, logLevel, options) {
-        const logger = ( new BufferLogger(logLevel));
-        whenProviderRegistered(resource, this.fileService).then(() => logger.logger = ( new FileLogger(
-            resource,
-            logger.getLevel(),
-            !!options?.donotUseFormatters,
-            this.fileService
-        )));
-        return logger;
-    }
-}
-export { FileLoggerService };