@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

package/vscode/src/vs/editor/contrib/folding/browser/syntaxRangeProvider.js

@@ -0,0 +1,168 @@
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { MAX_LINE_NUMBER, FoldingRegions } from './foldingRanges.js';
+const foldingContext = {};
+const ID_SYNTAX_PROVIDER = 'syntax';
+class SyntaxRangeProvider {
+    constructor(editorModel, providers, handleFoldingRangesChange, foldingRangesLimit, fallbackRangeProvider
+    ) {
+        this.editorModel = editorModel;
+        this.providers = providers;
+        this.handleFoldingRangesChange = handleFoldingRangesChange;
+        this.foldingRangesLimit = foldingRangesLimit;
+        this.fallbackRangeProvider = fallbackRangeProvider;
+        this.id = ID_SYNTAX_PROVIDER;
+        this.disposables = ( new DisposableStore());
+        if (fallbackRangeProvider) {
+            this.disposables.add(fallbackRangeProvider);
+        }
+        for (const provider of providers) {
+            if (typeof provider.onDidChange === 'function') {
+                this.disposables.add(provider.onDidChange(handleFoldingRangesChange));
+            }
+        }
+    }
+    compute(cancellationToken) {
+        return collectSyntaxRanges(this.providers, this.editorModel, cancellationToken).then(ranges => {
+            if (ranges) {
+                const res = sanitizeRanges(ranges, this.foldingRangesLimit);
+                return res;
+            }
+            return this.fallbackRangeProvider?.compute(cancellationToken) ?? null;
+        });
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+}
+function collectSyntaxRanges(providers, model, cancellationToken) {
+    let rangeData = null;
+    const promises = ( providers.map((provider, i) => {
+        return Promise.resolve(provider.provideFoldingRanges(model, foldingContext, cancellationToken)).then(ranges => {
+            if (cancellationToken.isCancellationRequested) {
+                return;
+            }
+            if (Array.isArray(ranges)) {
+                if (!Array.isArray(rangeData)) {
+                    rangeData = [];
+                }
+                const nLines = model.getLineCount();
+                for (const r of ranges) {
+                    if (r.start > 0 && r.end > r.start && r.end <= nLines) {
+                        rangeData.push({ start: r.start, end: r.end, rank: i, kind: r.kind });
+                    }
+                }
+            }
+        }, onUnexpectedExternalError);
+    }));
+    return Promise.all(promises).then(_ => {
+        return rangeData;
+    });
+}
+class RangesCollector {
+    constructor(foldingRangesLimit) {
+        this._startIndexes = [];
+        this._endIndexes = [];
+        this._nestingLevels = [];
+        this._nestingLevelCounts = [];
+        this._types = [];
+        this._length = 0;
+        this._foldingRangesLimit = foldingRangesLimit;
+    }
+    add(startLineNumber, endLineNumber, type, nestingLevel) {
+        if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {
+            return;
+        }
+        const index = this._length;
+        this._startIndexes[index] = startLineNumber;
+        this._endIndexes[index] = endLineNumber;
+        this._nestingLevels[index] = nestingLevel;
+        this._types[index] = type;
+        this._length++;
+        if (nestingLevel < 30) {
+            this._nestingLevelCounts[nestingLevel] = (this._nestingLevelCounts[nestingLevel] || 0) + 1;
+        }
+    }
+    toIndentRanges() {
+        const limit = this._foldingRangesLimit.limit;
+        if (this._length <= limit) {
+            this._foldingRangesLimit.update(this._length, false);
+            const startIndexes = ( new Uint32Array(this._length));
+            const endIndexes = ( new Uint32Array(this._length));
+            for (let i = 0; i < this._length; i++) {
+                startIndexes[i] = this._startIndexes[i];
+                endIndexes[i] = this._endIndexes[i];
+            }
+            return ( new FoldingRegions(startIndexes, endIndexes, this._types));
+        }
+        else {
+            this._foldingRangesLimit.update(this._length, limit);
+            let entries = 0;
+            let maxLevel = this._nestingLevelCounts.length;
+            for (let i = 0; i < this._nestingLevelCounts.length; i++) {
+                const n = this._nestingLevelCounts[i];
+                if (n) {
+                    if (n + entries > limit) {
+                        maxLevel = i;
+                        break;
+                    }
+                    entries += n;
+                }
+            }
+            const startIndexes = ( new Uint32Array(limit));
+            const endIndexes = ( new Uint32Array(limit));
+            const types = [];
+            for (let i = 0, k = 0; i < this._length; i++) {
+                const level = this._nestingLevels[i];
+                if (level < maxLevel || (level === maxLevel && entries++ < limit)) {
+                    startIndexes[k] = this._startIndexes[i];
+                    endIndexes[k] = this._endIndexes[i];
+                    types[k] = this._types[i];
+                    k++;
+                }
+            }
+            return ( new FoldingRegions(startIndexes, endIndexes, types));
+        }
+    }
+}
+function sanitizeRanges(rangeData, foldingRangesLimit) {
+    const sorted = rangeData.sort((d1, d2) => {
+        let diff = d1.start - d2.start;
+        if (diff === 0) {
+            diff = d1.rank - d2.rank;
+        }
+        return diff;
+    });
+    const collector = ( new RangesCollector(foldingRangesLimit));
+    let top = undefined;
+    const previous = [];
+    for (const entry of sorted) {
+        if (!top) {
+            top = entry;
+            collector.add(entry.start, entry.end, entry.kind && entry.kind.value, previous.length);
+        }
+        else {
+            if (entry.start > top.start) {
+                if (entry.end <= top.end) {
+                    previous.push(top);
+                    top = entry;
+                    collector.add(entry.start, entry.end, entry.kind && entry.kind.value, previous.length);
+                }
+                else {
+                    if (entry.start > top.end) {
+                        do {
+                            top = previous.pop();
+                        } while (top && entry.start > top.end);
+                        if (top) {
+                            previous.push(top);
+                        }
+                        top = entry;
+                    }
+                    collector.add(entry.start, entry.end, entry.kind && entry.kind.value, previous.length);
+                }
+            }
+        }
+    }
+    return collector.toIndentRanges();
+}
+export { SyntaxRangeProvider, sanitizeRanges };

package/vscode/src/vs/editor/contrib/fontZoom/browser/fontZoom.js

@@ -0,0 +1,57 @@
+import { registerEditorAction, EditorAction } from '../../../browser/editorExtensions.js';
+import { EditorZoom } from '../../../common/config/editorZoom.js';
+import { localizeWithPath } from '../../../../nls.js';
+class EditorFontZoomIn extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.fontZoomIn',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/fontZoom/browser/fontZoom',
+                'EditorFontZoomIn.label',
+                "Editor Font Zoom In"
+            )),
+            alias: 'Editor Font Zoom In',
+            precondition: undefined
+        });
+    }
+    run(accessor, editor) {
+        EditorZoom.setZoomLevel(EditorZoom.getZoomLevel() + 1);
+    }
+}
+class EditorFontZoomOut extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.fontZoomOut',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/fontZoom/browser/fontZoom',
+                'EditorFontZoomOut.label',
+                "Editor Font Zoom Out"
+            )),
+            alias: 'Editor Font Zoom Out',
+            precondition: undefined
+        });
+    }
+    run(accessor, editor) {
+        EditorZoom.setZoomLevel(EditorZoom.getZoomLevel() - 1);
+    }
+}
+class EditorFontZoomReset extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.fontZoomReset',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/fontZoom/browser/fontZoom',
+                'EditorFontZoomReset.label',
+                "Editor Font Zoom Reset"
+            )),
+            alias: 'Editor Font Zoom Reset',
+            precondition: undefined
+        });
+    }
+    run(accessor, editor) {
+        EditorZoom.setZoomLevel(0);
+    }
+}
+registerEditorAction(EditorFontZoomIn);
+registerEditorAction(EditorFontZoomOut);
+registerEditorAction(EditorFontZoomReset);

package/vscode/src/vs/editor/contrib/format/browser/format.js

@@ -0,0 +1,374 @@
+import { asArray, isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { LinkedList } from '../../../../base/common/linkedList.js';
+import { assertType } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { EditorStateCancellationTokenSource, TextModelCancellationTokenSource } from '../../editorState/browser/editorState.js';
+import { isCodeEditor } from '../../../browser/editorBrowser.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
+import { IEditorWorkerService } from '../../../common/services/editorWorker.js';
+import { ITextModelService } from '../../../common/services/resolverService.js';
+import { FormattingEdit } from './formattingEdit.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { ExtensionIdentifierSet } from '../../../../platform/extensions/common/extensions.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IAccessibleNotificationService } from '../../../../platform/accessibility/common/accessibility.js';
+function getRealAndSyntheticDocumentFormattersOrdered(documentFormattingEditProvider, documentRangeFormattingEditProvider, model) {
+    const result = [];
+    const seen = ( new ExtensionIdentifierSet());
+    const docFormatter = documentFormattingEditProvider.ordered(model);
+    for (const formatter of docFormatter) {
+        result.push(formatter);
+        if (formatter.extensionId) {
+            seen.add(formatter.extensionId);
+        }
+    }
+    const rangeFormatter = documentRangeFormattingEditProvider.ordered(model);
+    for (const formatter of rangeFormatter) {
+        if (formatter.extensionId) {
+            if (( seen.has(formatter.extensionId))) {
+                continue;
+            }
+            seen.add(formatter.extensionId);
+        }
+        result.push({
+            displayName: formatter.displayName,
+            extensionId: formatter.extensionId,
+            provideDocumentFormattingEdits(model, options, token) {
+                return formatter.provideDocumentRangeFormattingEdits(model, model.getFullModelRange(), options, token);
+            }
+        });
+    }
+    return result;
+}
+class FormattingConflicts {
+    static { this._selectors = ( new LinkedList()); }
+    static setFormatterSelector(selector) {
+        const remove = FormattingConflicts._selectors.unshift(selector);
+        return { dispose: remove };
+    }
+    static async select(formatter, document, mode) {
+        if (formatter.length === 0) {
+            return undefined;
+        }
+        const selector = Iterable.first(FormattingConflicts._selectors);
+        if (selector) {
+            return await selector(formatter, document, mode);
+        }
+        return undefined;
+    }
+}
+async function formatDocumentRangesWithSelectedProvider(accessor, editorOrModel, rangeOrRanges, mode, progress, token, userGesture) {
+    const instaService = accessor.get(IInstantiationService);
+    const { documentRangeFormattingEditProvider: documentRangeFormattingEditProviderRegistry } = accessor.get(ILanguageFeaturesService);
+    const model = isCodeEditor(editorOrModel) ? editorOrModel.getModel() : editorOrModel;
+    const provider = documentRangeFormattingEditProviderRegistry.ordered(model);
+    const selected = await FormattingConflicts.select(provider, model, mode);
+    if (selected) {
+        progress.report(selected);
+        await instaService.invokeFunction(formatDocumentRangesWithProvider, selected, editorOrModel, rangeOrRanges, token, userGesture);
+    }
+}
+async function formatDocumentRangesWithProvider(accessor, provider, editorOrModel, rangeOrRanges, token, userGesture) {
+    const workerService = accessor.get(IEditorWorkerService);
+    const logService = accessor.get(ILogService);
+    const accessibleNotificationService = accessor.get(IAccessibleNotificationService);
+    let model;
+    let cts;
+    if (isCodeEditor(editorOrModel)) {
+        model = editorOrModel.getModel();
+        cts = ( new EditorStateCancellationTokenSource(
+            editorOrModel,
+            1  | 4 ,
+            undefined,
+            token
+        ));
+    }
+    else {
+        model = editorOrModel;
+        cts = ( new TextModelCancellationTokenSource(editorOrModel, token));
+    }
+    const ranges = [];
+    let len = 0;
+    for (const range of asArray(rangeOrRanges).sort(Range.compareRangesUsingStarts)) {
+        if (len > 0 && Range.areIntersectingOrTouching(ranges[len - 1], range)) {
+            ranges[len - 1] = Range.fromPositions(ranges[len - 1].getStartPosition(), range.getEndPosition());
+        }
+        else {
+            len = ranges.push(range);
+        }
+    }
+    const computeEdits = async (range) => {
+        logService.trace(`[format][provideDocumentRangeFormattingEdits] (request)`, provider.extensionId?.value, range);
+        const result = (await provider.provideDocumentRangeFormattingEdits(model, range, model.getFormattingOptions(), cts.token)) || [];
+        logService.trace(`[format][provideDocumentRangeFormattingEdits] (response)`, provider.extensionId?.value, result);
+        return result;
+    };
+    const hasIntersectingEdit = (a, b) => {
+        if (!a.length || !b.length) {
+            return false;
+        }
+        const mergedA = a.reduce((acc, val) => { return Range.plusRange(acc, val.range); }, a[0].range);
+        if (!( b.some(x => { return Range.intersectRanges(mergedA, x.range); }))) {
+            return false;
+        }
+        for (const edit of a) {
+            for (const otherEdit of b) {
+                if (Range.intersectRanges(edit.range, otherEdit.range)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    const allEdits = [];
+    const rawEditsList = [];
+    try {
+        if (typeof provider.provideDocumentRangesFormattingEdits === 'function') {
+            logService.trace(`[format][provideDocumentRangeFormattingEdits] (request)`, provider.extensionId?.value, ranges);
+            const result = (await provider.provideDocumentRangesFormattingEdits(model, ranges, model.getFormattingOptions(), cts.token)) || [];
+            logService.trace(`[format][provideDocumentRangeFormattingEdits] (response)`, provider.extensionId?.value, result);
+            rawEditsList.push(result);
+        }
+        else {
+            for (const range of ranges) {
+                if (cts.token.isCancellationRequested) {
+                    return true;
+                }
+                rawEditsList.push(await computeEdits(range));
+            }
+            for (let i = 0; i < ranges.length; ++i) {
+                for (let j = i + 1; j < ranges.length; ++j) {
+                    if (cts.token.isCancellationRequested) {
+                        return true;
+                    }
+                    if (hasIntersectingEdit(rawEditsList[i], rawEditsList[j])) {
+                        const mergedRange = Range.plusRange(ranges[i], ranges[j]);
+                        const edits = await computeEdits(mergedRange);
+                        ranges.splice(j, 1);
+                        ranges.splice(i, 1);
+                        ranges.push(mergedRange);
+                        rawEditsList.splice(j, 1);
+                        rawEditsList.splice(i, 1);
+                        rawEditsList.push(edits);
+                        i = 0;
+                        j = 0;
+                    }
+                }
+            }
+        }
+        for (const rawEdits of rawEditsList) {
+            if (cts.token.isCancellationRequested) {
+                return true;
+            }
+            const minimalEdits = await workerService.computeMoreMinimalEdits(model.uri, rawEdits);
+            if (minimalEdits) {
+                allEdits.push(...minimalEdits);
+            }
+        }
+    }
+    finally {
+        cts.dispose();
+    }
+    if (allEdits.length === 0) {
+        return false;
+    }
+    if (isCodeEditor(editorOrModel)) {
+        FormattingEdit.execute(editorOrModel, allEdits, true);
+        editorOrModel.revealPositionInCenterIfOutsideViewport(editorOrModel.getPosition(), 1 );
+    }
+    else {
+        const [{ range }] = allEdits;
+        const initialSelection = ( new Selection(
+            range.startLineNumber,
+            range.startColumn,
+            range.endLineNumber,
+            range.endColumn
+        ));
+        model.pushEditOperations([initialSelection], ( allEdits.map(edit => {
+            return {
+                text: edit.text,
+                range: Range.lift(edit.range),
+                forceMoveMarkers: true
+            };
+        })), undoEdits => {
+            for (const { range } of undoEdits) {
+                if (Range.areIntersectingOrTouching(range, initialSelection)) {
+                    return [( new Selection(
+                        range.startLineNumber,
+                        range.startColumn,
+                        range.endLineNumber,
+                        range.endColumn
+                    ))];
+                }
+            }
+            return null;
+        });
+    }
+    accessibleNotificationService.notify("format" , userGesture);
+    return true;
+}
+async function formatDocumentWithSelectedProvider(accessor, editorOrModel, mode, progress, token, userGesture) {
+    const instaService = accessor.get(IInstantiationService);
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const model = isCodeEditor(editorOrModel) ? editorOrModel.getModel() : editorOrModel;
+    const provider = getRealAndSyntheticDocumentFormattersOrdered(languageFeaturesService.documentFormattingEditProvider, languageFeaturesService.documentRangeFormattingEditProvider, model);
+    const selected = await FormattingConflicts.select(provider, model, mode);
+    if (selected) {
+        progress.report(selected);
+        await instaService.invokeFunction(formatDocumentWithProvider, selected, editorOrModel, mode, token, userGesture);
+    }
+}
+async function formatDocumentWithProvider(accessor, provider, editorOrModel, mode, token, userGesture) {
+    const workerService = accessor.get(IEditorWorkerService);
+    const accessibleNotificationService = accessor.get(IAccessibleNotificationService);
+    let model;
+    let cts;
+    if (isCodeEditor(editorOrModel)) {
+        model = editorOrModel.getModel();
+        cts = ( new EditorStateCancellationTokenSource(
+            editorOrModel,
+            1  | 4 ,
+            undefined,
+            token
+        ));
+    }
+    else {
+        model = editorOrModel;
+        cts = ( new TextModelCancellationTokenSource(editorOrModel, token));
+    }
+    let edits;
+    try {
+        const rawEdits = await provider.provideDocumentFormattingEdits(model, model.getFormattingOptions(), cts.token);
+        edits = await workerService.computeMoreMinimalEdits(model.uri, rawEdits);
+        if (cts.token.isCancellationRequested) {
+            return true;
+        }
+    }
+    finally {
+        cts.dispose();
+    }
+    if (!edits || edits.length === 0) {
+        return false;
+    }
+    if (isCodeEditor(editorOrModel)) {
+        FormattingEdit.execute(editorOrModel, edits, mode !== 2 );
+        if (mode !== 2 ) {
+            editorOrModel.revealPositionInCenterIfOutsideViewport(editorOrModel.getPosition(), 1 );
+        }
+    }
+    else {
+        const [{ range }] = edits;
+        const initialSelection = ( new Selection(
+            range.startLineNumber,
+            range.startColumn,
+            range.endLineNumber,
+            range.endColumn
+        ));
+        model.pushEditOperations([initialSelection], ( edits.map(edit => {
+            return {
+                text: edit.text,
+                range: Range.lift(edit.range),
+                forceMoveMarkers: true
+            };
+        })), undoEdits => {
+            for (const { range } of undoEdits) {
+                if (Range.areIntersectingOrTouching(range, initialSelection)) {
+                    return [( new Selection(
+                        range.startLineNumber,
+                        range.startColumn,
+                        range.endLineNumber,
+                        range.endColumn
+                    ))];
+                }
+            }
+            return null;
+        });
+    }
+    accessibleNotificationService.notify("format" , userGesture);
+    return true;
+}
+async function getDocumentRangeFormattingEditsUntilResult(workerService, languageFeaturesService, model, range, options, token) {
+    const providers = languageFeaturesService.documentRangeFormattingEditProvider.ordered(model);
+    for (const provider of providers) {
+        const rawEdits = await Promise.resolve(provider.provideDocumentRangeFormattingEdits(model, range, options, token)).catch(onUnexpectedExternalError);
+        if (isNonEmptyArray(rawEdits)) {
+            return await workerService.computeMoreMinimalEdits(model.uri, rawEdits);
+        }
+    }
+    return undefined;
+}
+async function getDocumentFormattingEditsUntilResult(workerService, languageFeaturesService, model, options, token) {
+    const providers = getRealAndSyntheticDocumentFormattersOrdered(languageFeaturesService.documentFormattingEditProvider, languageFeaturesService.documentRangeFormattingEditProvider, model);
+    for (const provider of providers) {
+        const rawEdits = await Promise.resolve(provider.provideDocumentFormattingEdits(model, options, token)).catch(onUnexpectedExternalError);
+        if (isNonEmptyArray(rawEdits)) {
+            return await workerService.computeMoreMinimalEdits(model.uri, rawEdits);
+        }
+    }
+    return undefined;
+}
+function getOnTypeFormattingEdits(workerService, languageFeaturesService, model, position, ch, options, token) {
+    const providers = languageFeaturesService.onTypeFormattingEditProvider.ordered(model);
+    if (providers.length === 0) {
+        return Promise.resolve(undefined);
+    }
+    if (providers[0].autoFormatTriggerCharacters.indexOf(ch) < 0) {
+        return Promise.resolve(undefined);
+    }
+    return Promise.resolve(providers[0].provideOnTypeFormattingEdits(model, position, ch, options, token)).catch(onUnexpectedExternalError).then(edits => {
+        return workerService.computeMoreMinimalEdits(model.uri, edits);
+    });
+}
+CommandsRegistry.registerCommand('_executeFormatRangeProvider', async function (accessor, ...args) {
+    const [resource, range, options] = args;
+    assertType(URI.isUri(resource));
+    assertType(Range.isIRange(range));
+    const resolverService = accessor.get(ITextModelService);
+    const workerService = accessor.get(IEditorWorkerService);
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const reference = await resolverService.createModelReference(resource);
+    try {
+        return getDocumentRangeFormattingEditsUntilResult(workerService, languageFeaturesService, reference.object.textEditorModel, Range.lift(range), options, CancellationToken.None);
+    }
+    finally {
+        reference.dispose();
+    }
+});
+CommandsRegistry.registerCommand('_executeFormatDocumentProvider', async function (accessor, ...args) {
+    const [resource, options] = args;
+    assertType(URI.isUri(resource));
+    const resolverService = accessor.get(ITextModelService);
+    const workerService = accessor.get(IEditorWorkerService);
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const reference = await resolverService.createModelReference(resource);
+    try {
+        return getDocumentFormattingEditsUntilResult(workerService, languageFeaturesService, reference.object.textEditorModel, options, CancellationToken.None);
+    }
+    finally {
+        reference.dispose();
+    }
+});
+CommandsRegistry.registerCommand('_executeFormatOnTypeProvider', async function (accessor, ...args) {
+    const [resource, position, ch, options] = args;
+    assertType(URI.isUri(resource));
+    assertType(Position.isIPosition(position));
+    assertType(typeof ch === 'string');
+    const resolverService = accessor.get(ITextModelService);
+    const workerService = accessor.get(IEditorWorkerService);
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const reference = await resolverService.createModelReference(resource);
+    try {
+        return getOnTypeFormattingEdits(workerService, languageFeaturesService, reference.object.textEditorModel, Position.lift(position), ch, options, CancellationToken.None);
+    }
+    finally {
+        reference.dispose();
+    }
+});
+export { FormattingConflicts, formatDocumentRangesWithProvider, formatDocumentRangesWithSelectedProvider, formatDocumentWithProvider, formatDocumentWithSelectedProvider, getDocumentFormattingEditsUntilResult, getDocumentRangeFormattingEditsUntilResult, getOnTypeFormattingEdits, getRealAndSyntheticDocumentFormattersOrdered };