claude-flow-novice 2.3.1 → 2.3.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/format/browser/format.js

@@ -0,0 +1,360 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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';
+export function getRealAndSyntheticDocumentFormattersOrdered(documentFormattingEditProvider, documentRangeFormattingEditProvider, model) {
+    const result = [];
+    const seen = new ExtensionIdentifierSet();
+    // (1) add all document formatter
+    const docFormatter = documentFormattingEditProvider.ordered(model);
+    for (const formatter of docFormatter) {
+        result.push(formatter);
+        if (formatter.extensionId) {
+            seen.add(formatter.extensionId);
+        }
+    }
+    // (2) add all range formatter as document formatter (unless the same extension already did that)
+    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;
+}
+export class FormattingConflicts {
+    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;
+    }
+}
+FormattingConflicts._selectors = new LinkedList();
+export 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);
+    }
+}
+export async function formatDocumentRangesWithProvider(accessor, provider, editorOrModel, rangeOrRanges, token, userGesture) {
+    var _a, _b;
+    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 /* CodeEditorStateFlag.Value */ | 4 /* CodeEditorStateFlag.Position */, undefined, token);
+    }
+    else {
+        model = editorOrModel;
+        cts = new TextModelCancellationTokenSource(editorOrModel, token);
+    }
+    // make sure that ranges don't overlap nor touch each other
+    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) => {
+        var _a, _b;
+        logService.trace(`[format][provideDocumentRangeFormattingEdits] (request)`, (_a = provider.extensionId) === null || _a === void 0 ? void 0 : _a.value, range);
+        const result = (await provider.provideDocumentRangeFormattingEdits(model, range, model.getFormattingOptions(), cts.token)) || [];
+        logService.trace(`[format][provideDocumentRangeFormattingEdits] (response)`, (_b = provider.extensionId) === null || _b === void 0 ? void 0 : _b.value, result);
+        return result;
+    };
+    const hasIntersectingEdit = (a, b) => {
+        if (!a.length || !b.length) {
+            return false;
+        }
+        // quick exit if the list of ranges are completely unrelated [O(n)]
+        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;
+        }
+        // fallback to a complete check [O(n^2)]
+        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)`, (_a = provider.extensionId) === null || _a === void 0 ? void 0 : _a.value, ranges);
+            const result = (await provider.provideDocumentRangesFormattingEdits(model, ranges, model.getFormattingOptions(), cts.token)) || [];
+            logService.trace(`[format][provideDocumentRangeFormattingEdits] (response)`, (_b = provider.extensionId) === null || _b === void 0 ? void 0 : _b.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])) {
+                        // Merge ranges i and j into a single range, recompute the associated edits
+                        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);
+                        // Restart scanning
+                        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)) {
+        // use editor to apply edits
+        FormattingEdit.execute(editorOrModel, allEdits, true);
+        editorOrModel.revealPositionInCenterIfOutsideViewport(editorOrModel.getPosition(), 1 /* ScrollType.Immediate */);
+    }
+    else {
+        // use model to apply edits
+        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" /* AccessibleNotificationEvent.Format */, userGesture);
+    return true;
+}
+export 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);
+    }
+}
+export 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 /* CodeEditorStateFlag.Value */ | 4 /* CodeEditorStateFlag.Position */, 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)) {
+        // use editor to apply edits
+        FormattingEdit.execute(editorOrModel, edits, mode !== 2 /* FormattingMode.Silent */);
+        if (mode !== 2 /* FormattingMode.Silent */) {
+            editorOrModel.revealPositionInCenterIfOutsideViewport(editorOrModel.getPosition(), 1 /* ScrollType.Immediate */);
+        }
+    }
+    else {
+        // use model to apply edits
+        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" /* AccessibleNotificationEvent.Format */, userGesture);
+    return true;
+}
+export 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;
+}
+export 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;
+}
+export 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();
+    }
+});

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/format/browser/formatActions.js

@@ -0,0 +1,263 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { KeyChord } from '../../../../base/common/keyCodes.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { EditorAction, registerEditorAction, registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { ICodeEditorService } from '../../../browser/services/codeEditorService.js';
+import { CharacterSet } from '../../../common/core/characterClassifier.js';
+import { Range } from '../../../common/core/range.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { IEditorWorkerService } from '../../../common/services/editorWorker.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { formatDocumentRangesWithSelectedProvider, formatDocumentWithSelectedProvider, getOnTypeFormattingEdits } from './format.js';
+import { FormattingEdit } from './formattingEdit.js';
+import * as nls from '../../../../nls.js';
+import { IAccessibleNotificationService } from '../../../../platform/accessibility/common/accessibility.js';
+import { CommandsRegistry, ICommandService } from '../../../../platform/commands/common/commands.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IEditorProgressService, Progress } from '../../../../platform/progress/common/progress.js';
+let FormatOnType = class FormatOnType {
+    constructor(_editor, _languageFeaturesService, _workerService, _accessibleNotificationService) {
+        this._editor = _editor;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._workerService = _workerService;
+        this._accessibleNotificationService = _accessibleNotificationService;
+        this._disposables = new DisposableStore();
+        this._sessionDisposables = new DisposableStore();
+        this._disposables.add(_languageFeaturesService.onTypeFormattingEditProvider.onDidChange(this._update, this));
+        this._disposables.add(_editor.onDidChangeModel(() => this._update()));
+        this._disposables.add(_editor.onDidChangeModelLanguage(() => this._update()));
+        this._disposables.add(_editor.onDidChangeConfiguration(e => {
+            if (e.hasChanged(56 /* EditorOption.formatOnType */)) {
+                this._update();
+            }
+        }));
+        this._update();
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._sessionDisposables.dispose();
+    }
+    _update() {
+        // clean up
+        this._sessionDisposables.clear();
+        // we are disabled
+        if (!this._editor.getOption(56 /* EditorOption.formatOnType */)) {
+            return;
+        }
+        // no model
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const model = this._editor.getModel();
+        // no support
+        const [support] = this._languageFeaturesService.onTypeFormattingEditProvider.ordered(model);
+        if (!support || !support.autoFormatTriggerCharacters) {
+            return;
+        }
+        // register typing listeners that will trigger the format
+        const triggerChars = new CharacterSet();
+        for (const ch of support.autoFormatTriggerCharacters) {
+            triggerChars.add(ch.charCodeAt(0));
+        }
+        this._sessionDisposables.add(this._editor.onDidType((text) => {
+            const lastCharCode = text.charCodeAt(text.length - 1);
+            if (triggerChars.has(lastCharCode)) {
+                this._trigger(String.fromCharCode(lastCharCode));
+            }
+        }));
+    }
+    _trigger(ch) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        if (this._editor.getSelections().length > 1 || !this._editor.getSelection().isEmpty()) {
+            return;
+        }
+        const model = this._editor.getModel();
+        const position = this._editor.getPosition();
+        const cts = new CancellationTokenSource();
+        // install a listener that checks if edits happens before the
+        // position on which we format right now. If so, we won't
+        // apply the format edits
+        const unbind = this._editor.onDidChangeModelContent((e) => {
+            if (e.isFlush) {
+                // a model.setValue() was called
+                // cancel only once
+                cts.cancel();
+                unbind.dispose();
+                return;
+            }
+            for (let i = 0, len = e.changes.length; i < len; i++) {
+                const change = e.changes[i];
+                if (change.range.endLineNumber <= position.lineNumber) {
+                    // cancel only once
+                    cts.cancel();
+                    unbind.dispose();
+                    return;
+                }
+            }
+        });
+        getOnTypeFormattingEdits(this._workerService, this._languageFeaturesService, model, position, ch, model.getFormattingOptions(), cts.token).then(edits => {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (isNonEmptyArray(edits)) {
+                this._accessibleNotificationService.notify("format" /* AccessibleNotificationEvent.Format */, false);
+                FormattingEdit.execute(this._editor, edits, true);
+            }
+        }).finally(() => {
+            unbind.dispose();
+        });
+    }
+};
+FormatOnType.ID = 'editor.contrib.autoFormat';
+FormatOnType = __decorate([
+    __param(1, ILanguageFeaturesService),
+    __param(2, IEditorWorkerService),
+    __param(3, IAccessibleNotificationService)
+], FormatOnType);
+export { FormatOnType };
+let FormatOnPaste = class FormatOnPaste {
+    constructor(editor, _languageFeaturesService, _instantiationService) {
+        this.editor = editor;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._instantiationService = _instantiationService;
+        this._callOnDispose = new DisposableStore();
+        this._callOnModel = new DisposableStore();
+        this._callOnDispose.add(editor.onDidChangeConfiguration(() => this._update()));
+        this._callOnDispose.add(editor.onDidChangeModel(() => this._update()));
+        this._callOnDispose.add(editor.onDidChangeModelLanguage(() => this._update()));
+        this._callOnDispose.add(_languageFeaturesService.documentRangeFormattingEditProvider.onDidChange(this._update, this));
+    }
+    dispose() {
+        this._callOnDispose.dispose();
+        this._callOnModel.dispose();
+    }
+    _update() {
+        // clean up
+        this._callOnModel.clear();
+        // we are disabled
+        if (!this.editor.getOption(55 /* EditorOption.formatOnPaste */)) {
+            return;
+        }
+        // no model
+        if (!this.editor.hasModel()) {
+            return;
+        }
+        // no formatter
+        if (!this._languageFeaturesService.documentRangeFormattingEditProvider.has(this.editor.getModel())) {
+            return;
+        }
+        this._callOnModel.add(this.editor.onDidPaste(({ range }) => this._trigger(range)));
+    }
+    _trigger(range) {
+        if (!this.editor.hasModel()) {
+            return;
+        }
+        if (this.editor.getSelections().length > 1) {
+            return;
+        }
+        this._instantiationService.invokeFunction(formatDocumentRangesWithSelectedProvider, this.editor, range, 2 /* FormattingMode.Silent */, Progress.None, CancellationToken.None, false).catch(onUnexpectedError);
+    }
+};
+FormatOnPaste.ID = 'editor.contrib.formatOnPaste';
+FormatOnPaste = __decorate([
+    __param(1, ILanguageFeaturesService),
+    __param(2, IInstantiationService)
+], FormatOnPaste);
+class FormatDocumentAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.formatDocument',
+            label: nls.localize('formatDocument.label', "Format Document"),
+            alias: 'Format Document',
+            precondition: ContextKeyExpr.and(EditorContextKeys.notInCompositeEditor, EditorContextKeys.writable, EditorContextKeys.hasDocumentFormattingProvider),
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 1024 /* KeyMod.Shift */ | 512 /* KeyMod.Alt */ | 36 /* KeyCode.KeyF */,
+                linux: { primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 39 /* KeyCode.KeyI */ },
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            contextMenuOpts: {
+                group: '1_modification',
+                order: 1.3
+            }
+        });
+    }
+    async run(accessor, editor) {
+        if (editor.hasModel()) {
+            const instaService = accessor.get(IInstantiationService);
+            const progressService = accessor.get(IEditorProgressService);
+            await progressService.showWhile(instaService.invokeFunction(formatDocumentWithSelectedProvider, editor, 1 /* FormattingMode.Explicit */, Progress.None, CancellationToken.None, true), 250);
+        }
+    }
+}
+class FormatSelectionAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.formatSelection',
+            label: nls.localize('formatSelection.label', "Format Selection"),
+            alias: 'Format Selection',
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasDocumentSelectionFormattingProvider),
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 36 /* KeyCode.KeyF */),
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            contextMenuOpts: {
+                when: EditorContextKeys.hasNonEmptySelection,
+                group: '1_modification',
+                order: 1.31
+            }
+        });
+    }
+    async run(accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const instaService = accessor.get(IInstantiationService);
+        const model = editor.getModel();
+        const ranges = editor.getSelections().map(range => {
+            return range.isEmpty()
+                ? new Range(range.startLineNumber, 1, range.startLineNumber, model.getLineMaxColumn(range.startLineNumber))
+                : range;
+        });
+        const progressService = accessor.get(IEditorProgressService);
+        await progressService.showWhile(instaService.invokeFunction(formatDocumentRangesWithSelectedProvider, editor, ranges, 1 /* FormattingMode.Explicit */, Progress.None, CancellationToken.None, true), 250);
+    }
+}
+registerEditorContribution(FormatOnType.ID, FormatOnType, 2 /* EditorContributionInstantiation.BeforeFirstInteraction */);
+registerEditorContribution(FormatOnPaste.ID, FormatOnPaste, 2 /* EditorContributionInstantiation.BeforeFirstInteraction */);
+registerEditorAction(FormatDocumentAction);
+registerEditorAction(FormatSelectionAction);
+// this is the old format action that does both (format document OR format selection)
+// and we keep it here such that existing keybinding configurations etc will still work
+CommandsRegistry.registerCommand('editor.action.format', async (accessor) => {
+    const editor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+    if (!editor || !editor.hasModel()) {
+        return;
+    }
+    const commandService = accessor.get(ICommandService);
+    if (editor.getSelection().isEmpty()) {
+        await commandService.executeCommand('editor.action.formatDocument');
+    }
+    else {
+        await commandService.executeCommand('editor.action.formatSelection');
+    }
+});

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/format/browser/formattingEdit.js

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { EditOperation } from '../../../common/core/editOperation.js';
+import { Range } from '../../../common/core/range.js';
+import { StableEditorScrollState } from '../../../browser/stableEditorScroll.js';
+export class FormattingEdit {
+    static _handleEolEdits(editor, edits) {
+        let newEol = undefined;
+        const singleEdits = [];
+        for (const edit of edits) {
+            if (typeof edit.eol === 'number') {
+                newEol = edit.eol;
+            }
+            if (edit.range && typeof edit.text === 'string') {
+                singleEdits.push(edit);
+            }
+        }
+        if (typeof newEol === 'number') {
+            if (editor.hasModel()) {
+                editor.getModel().pushEOL(newEol);
+            }
+        }
+        return singleEdits;
+    }
+    static _isFullModelReplaceEdit(editor, edit) {
+        if (!editor.hasModel()) {
+            return false;
+        }
+        const model = editor.getModel();
+        const editRange = model.validateRange(edit.range);
+        const fullModelRange = model.getFullModelRange();
+        return fullModelRange.equalsRange(editRange);
+    }
+    static execute(editor, _edits, addUndoStops) {
+        if (addUndoStops) {
+            editor.pushUndoStop();
+        }
+        const scrollState = StableEditorScrollState.capture(editor);
+        const edits = FormattingEdit._handleEolEdits(editor, _edits);
+        if (edits.length === 1 && FormattingEdit._isFullModelReplaceEdit(editor, edits[0])) {
+            // We use replace semantics and hope that markers stay put...
+            editor.executeEdits('formatEditsCommand', edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text)));
+        }
+        else {
+            editor.executeEdits('formatEditsCommand', edits.map(edit => EditOperation.replaceMove(Range.lift(edit.range), edit.text)));
+        }
+        if (addUndoStops) {
+            editor.pushUndoStop();
+        }
+        scrollState.restoreRelativeVerticalPositionOfCursor(editor);
+    }
+}