claude-flow-novice 2.0.3 → 2.0.5

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

@@ -1,360 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,263 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,54 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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);
-    }
-}