claude-flow-novice 2.2.1 → 2.2.3

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

@@ -0,0 +1,284 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { coalesce, equals, isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { illegalArgument, isCancellationError, onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IBulkEditService } from '../../../browser/services/bulkEditService.js';
+import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { IModelService } from '../../../common/services/model.js';
+import { TextModelCancellationTokenSource } from '../../editorState/browser/editorState.js';
+import * as nls from '../../../../nls.js';
+import { CommandsRegistry, ICommandService } from '../../../../platform/commands/common/commands.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { Progress } from '../../../../platform/progress/common/progress.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { CodeActionItem, CodeActionKind, CodeActionTriggerSource, filtersAction, mayIncludeActionsOfKind } from '../common/types.js';
+export const codeActionCommandId = 'editor.action.codeAction';
+export const quickFixCommandId = 'editor.action.quickFix';
+export const autoFixCommandId = 'editor.action.autoFix';
+export const refactorCommandId = 'editor.action.refactor';
+export const sourceActionCommandId = 'editor.action.sourceAction';
+export const organizeImportsCommandId = 'editor.action.organizeImports';
+export const fixAllCommandId = 'editor.action.fixAll';
+class ManagedCodeActionSet extends Disposable {
+    static codeActionsPreferredComparator(a, b) {
+        if (a.isPreferred && !b.isPreferred) {
+            return -1;
+        }
+        else if (!a.isPreferred && b.isPreferred) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    static codeActionsComparator({ action: a }, { action: b }) {
+        if (a.isAI && !b.isAI) {
+            return 1;
+        }
+        else if (!a.isAI && b.isAI) {
+            return -1;
+        }
+        if (isNonEmptyArray(a.diagnostics)) {
+            return isNonEmptyArray(b.diagnostics) ? ManagedCodeActionSet.codeActionsPreferredComparator(a, b) : -1;
+        }
+        else if (isNonEmptyArray(b.diagnostics)) {
+            return 1;
+        }
+        else {
+            return ManagedCodeActionSet.codeActionsPreferredComparator(a, b); // both have no diagnostics
+        }
+    }
+    constructor(actions, documentation, disposables) {
+        super();
+        this.documentation = documentation;
+        this._register(disposables);
+        this.allActions = [...actions].sort(ManagedCodeActionSet.codeActionsComparator);
+        this.validActions = this.allActions.filter(({ action }) => !action.disabled);
+    }
+    get hasAutoFix() {
+        return this.validActions.some(({ action: fix }) => !!fix.kind && CodeActionKind.QuickFix.contains(new CodeActionKind(fix.kind)) && !!fix.isPreferred);
+    }
+    get hasAIFix() {
+        return this.validActions.some(({ action: fix }) => !!fix.isAI);
+    }
+    get allAIFixes() {
+        return this.validActions.every(({ action: fix }) => !!fix.isAI);
+    }
+}
+const emptyCodeActionsResponse = { actions: [], documentation: undefined };
+export async function getCodeActions(registry, model, rangeOrSelection, trigger, progress, token) {
+    var _a;
+    const filter = trigger.filter || {};
+    const notebookFilter = {
+        ...filter,
+        excludes: [...(filter.excludes || []), CodeActionKind.Notebook],
+    };
+    const codeActionContext = {
+        only: (_a = filter.include) === null || _a === void 0 ? void 0 : _a.value,
+        trigger: trigger.type,
+    };
+    const cts = new TextModelCancellationTokenSource(model, token);
+    // if the trigger is auto (autosave, lightbulb, etc), we should exclude notebook codeActions
+    const excludeNotebookCodeActions = (trigger.type === 2 /* languages.CodeActionTriggerType.Auto */);
+    const providers = getCodeActionProviders(registry, model, (excludeNotebookCodeActions) ? notebookFilter : filter);
+    const disposables = new DisposableStore();
+    const promises = providers.map(async (provider) => {
+        try {
+            progress.report(provider);
+            const providedCodeActions = await provider.provideCodeActions(model, rangeOrSelection, codeActionContext, cts.token);
+            if (providedCodeActions) {
+                disposables.add(providedCodeActions);
+            }
+            if (cts.token.isCancellationRequested) {
+                return emptyCodeActionsResponse;
+            }
+            const filteredActions = ((providedCodeActions === null || providedCodeActions === void 0 ? void 0 : providedCodeActions.actions) || []).filter(action => action && filtersAction(filter, action));
+            const documentation = getDocumentationFromProvider(provider, filteredActions, filter.include);
+            return {
+                actions: filteredActions.map(action => new CodeActionItem(action, provider)),
+                documentation
+            };
+        }
+        catch (err) {
+            if (isCancellationError(err)) {
+                throw err;
+            }
+            onUnexpectedExternalError(err);
+            return emptyCodeActionsResponse;
+        }
+    });
+    const listener = registry.onDidChange(() => {
+        const newProviders = registry.all(model);
+        if (!equals(newProviders, providers)) {
+            cts.cancel();
+        }
+    });
+    try {
+        const actions = await Promise.all(promises);
+        const allActions = actions.map(x => x.actions).flat();
+        const allDocumentation = [
+            ...coalesce(actions.map(x => x.documentation)),
+            ...getAdditionalDocumentationForShowingActions(registry, model, trigger, allActions)
+        ];
+        return new ManagedCodeActionSet(allActions, allDocumentation, disposables);
+    }
+    finally {
+        listener.dispose();
+        cts.dispose();
+    }
+}
+function getCodeActionProviders(registry, model, filter) {
+    return registry.all(model)
+        // Don't include providers that we know will not return code actions of interest
+        .filter(provider => {
+        if (!provider.providedCodeActionKinds) {
+            // We don't know what type of actions this provider will return.
+            return true;
+        }
+        return provider.providedCodeActionKinds.some(kind => mayIncludeActionsOfKind(filter, new CodeActionKind(kind)));
+    });
+}
+function* getAdditionalDocumentationForShowingActions(registry, model, trigger, actionsToShow) {
+    var _a, _b, _c;
+    if (model && actionsToShow.length) {
+        for (const provider of registry.all(model)) {
+            if (provider._getAdditionalMenuItems) {
+                yield* (_a = provider._getAdditionalMenuItems) === null || _a === void 0 ? void 0 : _a.call(provider, { trigger: trigger.type, only: (_c = (_b = trigger.filter) === null || _b === void 0 ? void 0 : _b.include) === null || _c === void 0 ? void 0 : _c.value }, actionsToShow.map(item => item.action));
+            }
+        }
+    }
+}
+function getDocumentationFromProvider(provider, providedCodeActions, only) {
+    if (!provider.documentation) {
+        return undefined;
+    }
+    const documentation = provider.documentation.map(entry => ({ kind: new CodeActionKind(entry.kind), command: entry.command }));
+    if (only) {
+        let currentBest;
+        for (const entry of documentation) {
+            if (entry.kind.contains(only)) {
+                if (!currentBest) {
+                    currentBest = entry;
+                }
+                else {
+                    // Take best match
+                    if (currentBest.kind.contains(entry.kind)) {
+                        currentBest = entry;
+                    }
+                }
+            }
+        }
+        if (currentBest) {
+            return currentBest === null || currentBest === void 0 ? void 0 : currentBest.command;
+        }
+    }
+    // Otherwise, check to see if any of the provided actions match.
+    for (const action of providedCodeActions) {
+        if (!action.kind) {
+            continue;
+        }
+        for (const entry of documentation) {
+            if (entry.kind.contains(new CodeActionKind(action.kind))) {
+                return entry.command;
+            }
+        }
+    }
+    return undefined;
+}
+export var ApplyCodeActionReason;
+(function (ApplyCodeActionReason) {
+    ApplyCodeActionReason["OnSave"] = "onSave";
+    ApplyCodeActionReason["FromProblemsView"] = "fromProblemsView";
+    ApplyCodeActionReason["FromCodeActions"] = "fromCodeActions";
+})(ApplyCodeActionReason || (ApplyCodeActionReason = {}));
+export async function applyCodeAction(accessor, item, codeActionReason, options, token = CancellationToken.None) {
+    var _a;
+    const bulkEditService = accessor.get(IBulkEditService);
+    const commandService = accessor.get(ICommandService);
+    const telemetryService = accessor.get(ITelemetryService);
+    const notificationService = accessor.get(INotificationService);
+    telemetryService.publicLog2('codeAction.applyCodeAction', {
+        codeActionTitle: item.action.title,
+        codeActionKind: item.action.kind,
+        codeActionIsPreferred: !!item.action.isPreferred,
+        reason: codeActionReason,
+    });
+    await item.resolve(token);
+    if (token.isCancellationRequested) {
+        return;
+    }
+    if ((_a = item.action.edit) === null || _a === void 0 ? void 0 : _a.edits.length) {
+        const result = await bulkEditService.apply(item.action.edit, {
+            editor: options === null || options === void 0 ? void 0 : options.editor,
+            label: item.action.title,
+            quotableLabel: item.action.title,
+            code: 'undoredo.codeAction',
+            respectAutoSaveConfig: codeActionReason !== ApplyCodeActionReason.OnSave,
+            showPreview: options === null || options === void 0 ? void 0 : options.preview,
+        });
+        if (!result.isApplied) {
+            return;
+        }
+    }
+    if (item.action.command) {
+        try {
+            await commandService.executeCommand(item.action.command.id, ...(item.action.command.arguments || []));
+        }
+        catch (err) {
+            const message = asMessage(err);
+            notificationService.error(typeof message === 'string'
+                ? message
+                : nls.localize('applyCodeActionFailed', "An unknown error occurred while applying the code action"));
+        }
+    }
+}
+function asMessage(err) {
+    if (typeof err === 'string') {
+        return err;
+    }
+    else if (err instanceof Error && typeof err.message === 'string') {
+        return err.message;
+    }
+    else {
+        return undefined;
+    }
+}
+CommandsRegistry.registerCommand('_executeCodeActionProvider', async function (accessor, resource, rangeOrSelection, kind, itemResolveCount) {
+    if (!(resource instanceof URI)) {
+        throw illegalArgument();
+    }
+    const { codeActionProvider } = accessor.get(ILanguageFeaturesService);
+    const model = accessor.get(IModelService).getModel(resource);
+    if (!model) {
+        throw illegalArgument();
+    }
+    const validatedRangeOrSelection = Selection.isISelection(rangeOrSelection)
+        ? Selection.liftSelection(rangeOrSelection)
+        : Range.isIRange(rangeOrSelection)
+            ? model.validateRange(rangeOrSelection)
+            : undefined;
+    if (!validatedRangeOrSelection) {
+        throw illegalArgument();
+    }
+    const include = typeof kind === 'string' ? new CodeActionKind(kind) : undefined;
+    const codeActionSet = await getCodeActions(codeActionProvider, model, validatedRangeOrSelection, { type: 1 /* languages.CodeActionTriggerType.Invoke */, triggerAction: CodeActionTriggerSource.Default, filter: { includeSourceActions: true, include } }, Progress.None, CancellationToken.None);
+    const resolving = [];
+    const resolveCount = Math.min(codeActionSet.validActions.length, typeof itemResolveCount === 'number' ? itemResolveCount : 0);
+    for (let i = 0; i < resolveCount; i++) {
+        resolving.push(codeActionSet.validActions[i].resolve(CancellationToken.None));
+    }
+    try {
+        await Promise.all(resolving);
+        return codeActionSet.validActions.map(item => item.action);
+    }
+    finally {
+        setTimeout(() => codeActionSet.dispose(), 100);
+    }
+});

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

@@ -0,0 +1,229 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { EditorAction, EditorCommand } from '../../../browser/editorExtensions.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { autoFixCommandId, codeActionCommandId, fixAllCommandId, organizeImportsCommandId, quickFixCommandId, refactorCommandId, sourceActionCommandId } from './codeAction.js';
+import * as nls from '../../../../nls.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { CodeActionCommandArgs, CodeActionKind, CodeActionTriggerSource } from '../common/types.js';
+import { CodeActionController } from './codeActionController.js';
+import { SUPPORTED_CODE_ACTIONS } from './codeActionModel.js';
+function contextKeyForSupportedActions(kind) {
+    return ContextKeyExpr.regex(SUPPORTED_CODE_ACTIONS.keys()[0], new RegExp('(\\s|^)' + escapeRegExpCharacters(kind.value) + '\\b'));
+}
+const argsSchema = {
+    type: 'object',
+    defaultSnippets: [{ body: { kind: '' } }],
+    properties: {
+        'kind': {
+            type: 'string',
+            description: nls.localize('args.schema.kind', "Kind of the code action to run."),
+        },
+        'apply': {
+            type: 'string',
+            description: nls.localize('args.schema.apply', "Controls when the returned actions are applied."),
+            default: "ifSingle" /* CodeActionAutoApply.IfSingle */,
+            enum: ["first" /* CodeActionAutoApply.First */, "ifSingle" /* CodeActionAutoApply.IfSingle */, "never" /* CodeActionAutoApply.Never */],
+            enumDescriptions: [
+                nls.localize('args.schema.apply.first', "Always apply the first returned code action."),
+                nls.localize('args.schema.apply.ifSingle', "Apply the first returned code action if it is the only one."),
+                nls.localize('args.schema.apply.never', "Do not apply the returned code actions."),
+            ]
+        },
+        'preferred': {
+            type: 'boolean',
+            default: false,
+            description: nls.localize('args.schema.preferred', "Controls if only preferred code actions should be returned."),
+        }
+    }
+};
+function triggerCodeActionsForEditorSelection(editor, notAvailableMessage, filter, autoApply, triggerAction = CodeActionTriggerSource.Default) {
+    if (editor.hasModel()) {
+        const controller = CodeActionController.get(editor);
+        controller === null || controller === void 0 ? void 0 : controller.manualTriggerAtCurrentPosition(notAvailableMessage, triggerAction, filter, autoApply);
+    }
+}
+export class QuickFixAction extends EditorAction {
+    constructor() {
+        super({
+            id: quickFixCommandId,
+            label: nls.localize('quickfix.trigger.label', "Quick Fix..."),
+            alias: 'Quick Fix...',
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider),
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 2048 /* KeyMod.CtrlCmd */ | 89 /* KeyCode.Period */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    run(_accessor, editor) {
+        return triggerCodeActionsForEditorSelection(editor, nls.localize('editor.action.quickFix.noneMessage', "No code actions available"), undefined, undefined, CodeActionTriggerSource.QuickFix);
+    }
+}
+export class CodeActionCommand extends EditorCommand {
+    constructor() {
+        super({
+            id: codeActionCommandId,
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider),
+            metadata: {
+                description: 'Trigger a code action',
+                args: [{ name: 'args', schema: argsSchema, }]
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor, userArgs) {
+        const args = CodeActionCommandArgs.fromUser(userArgs, {
+            kind: CodeActionKind.Empty,
+            apply: "ifSingle" /* CodeActionAutoApply.IfSingle */,
+        });
+        return triggerCodeActionsForEditorSelection(editor, typeof (userArgs === null || userArgs === void 0 ? void 0 : userArgs.kind) === 'string'
+            ? args.preferred
+                ? nls.localize('editor.action.codeAction.noneMessage.preferred.kind', "No preferred code actions for '{0}' available", userArgs.kind)
+                : nls.localize('editor.action.codeAction.noneMessage.kind', "No code actions for '{0}' available", userArgs.kind)
+            : args.preferred
+                ? nls.localize('editor.action.codeAction.noneMessage.preferred', "No preferred code actions available")
+                : nls.localize('editor.action.codeAction.noneMessage', "No code actions available"), {
+            include: args.kind,
+            includeSourceActions: true,
+            onlyIncludePreferredActions: args.preferred,
+        }, args.apply);
+    }
+}
+export class RefactorAction extends EditorAction {
+    constructor() {
+        super({
+            id: refactorCommandId,
+            label: nls.localize('refactor.label', "Refactor..."),
+            alias: 'Refactor...',
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider),
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 48 /* KeyCode.KeyR */,
+                mac: {
+                    primary: 256 /* KeyMod.WinCtrl */ | 1024 /* KeyMod.Shift */ | 48 /* KeyCode.KeyR */
+                },
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            contextMenuOpts: {
+                group: '1_modification',
+                order: 2,
+                when: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.Refactor)),
+            },
+            metadata: {
+                description: 'Refactor...',
+                args: [{ name: 'args', schema: argsSchema }]
+            }
+        });
+    }
+    run(_accessor, editor, userArgs) {
+        const args = CodeActionCommandArgs.fromUser(userArgs, {
+            kind: CodeActionKind.Refactor,
+            apply: "never" /* CodeActionAutoApply.Never */
+        });
+        return triggerCodeActionsForEditorSelection(editor, typeof (userArgs === null || userArgs === void 0 ? void 0 : userArgs.kind) === 'string'
+            ? args.preferred
+                ? nls.localize('editor.action.refactor.noneMessage.preferred.kind', "No preferred refactorings for '{0}' available", userArgs.kind)
+                : nls.localize('editor.action.refactor.noneMessage.kind', "No refactorings for '{0}' available", userArgs.kind)
+            : args.preferred
+                ? nls.localize('editor.action.refactor.noneMessage.preferred', "No preferred refactorings available")
+                : nls.localize('editor.action.refactor.noneMessage', "No refactorings available"), {
+            include: CodeActionKind.Refactor.contains(args.kind) ? args.kind : CodeActionKind.None,
+            onlyIncludePreferredActions: args.preferred
+        }, args.apply, CodeActionTriggerSource.Refactor);
+    }
+}
+export class SourceAction extends EditorAction {
+    constructor() {
+        super({
+            id: sourceActionCommandId,
+            label: nls.localize('source.label', "Source Action..."),
+            alias: 'Source Action...',
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider),
+            contextMenuOpts: {
+                group: '1_modification',
+                order: 2.1,
+                when: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.Source)),
+            },
+            metadata: {
+                description: 'Source Action...',
+                args: [{ name: 'args', schema: argsSchema }]
+            }
+        });
+    }
+    run(_accessor, editor, userArgs) {
+        const args = CodeActionCommandArgs.fromUser(userArgs, {
+            kind: CodeActionKind.Source,
+            apply: "never" /* CodeActionAutoApply.Never */
+        });
+        return triggerCodeActionsForEditorSelection(editor, typeof (userArgs === null || userArgs === void 0 ? void 0 : userArgs.kind) === 'string'
+            ? args.preferred
+                ? nls.localize('editor.action.source.noneMessage.preferred.kind', "No preferred source actions for '{0}' available", userArgs.kind)
+                : nls.localize('editor.action.source.noneMessage.kind', "No source actions for '{0}' available", userArgs.kind)
+            : args.preferred
+                ? nls.localize('editor.action.source.noneMessage.preferred', "No preferred source actions available")
+                : nls.localize('editor.action.source.noneMessage', "No source actions available"), {
+            include: CodeActionKind.Source.contains(args.kind) ? args.kind : CodeActionKind.None,
+            includeSourceActions: true,
+            onlyIncludePreferredActions: args.preferred,
+        }, args.apply, CodeActionTriggerSource.SourceAction);
+    }
+}
+export class OrganizeImportsAction extends EditorAction {
+    constructor() {
+        super({
+            id: organizeImportsCommandId,
+            label: nls.localize('organizeImports.label', "Organize Imports"),
+            alias: 'Organize Imports',
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.SourceOrganizeImports)),
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 1024 /* KeyMod.Shift */ | 512 /* KeyMod.Alt */ | 45 /* KeyCode.KeyO */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+        });
+    }
+    run(_accessor, editor) {
+        return triggerCodeActionsForEditorSelection(editor, nls.localize('editor.action.organize.noneMessage', "No organize imports action available"), { include: CodeActionKind.SourceOrganizeImports, includeSourceActions: true }, "ifSingle" /* CodeActionAutoApply.IfSingle */, CodeActionTriggerSource.OrganizeImports);
+    }
+}
+export class FixAllAction extends EditorAction {
+    constructor() {
+        super({
+            id: fixAllCommandId,
+            label: nls.localize('fixAll.label', "Fix All"),
+            alias: 'Fix All',
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.SourceFixAll))
+        });
+    }
+    run(_accessor, editor) {
+        return triggerCodeActionsForEditorSelection(editor, nls.localize('fixAll.noneMessage', "No fix all action available"), { include: CodeActionKind.SourceFixAll, includeSourceActions: true }, "ifSingle" /* CodeActionAutoApply.IfSingle */, CodeActionTriggerSource.FixAll);
+    }
+}
+export class AutoFixAction extends EditorAction {
+    constructor() {
+        super({
+            id: autoFixCommandId,
+            label: nls.localize('autoFix.label', "Auto Fix..."),
+            alias: 'Auto Fix...',
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.QuickFix)),
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 512 /* KeyMod.Alt */ | 1024 /* KeyMod.Shift */ | 89 /* KeyCode.Period */,
+                mac: {
+                    primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 89 /* KeyCode.Period */
+                },
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    run(_accessor, editor) {
+        return triggerCodeActionsForEditorSelection(editor, nls.localize('editor.action.autoFix.noneMessage', "No auto fixes available"), {
+            include: CodeActionKind.QuickFix,
+            onlyIncludePreferredActions: true
+        }, "ifSingle" /* CodeActionAutoApply.IfSingle */, CodeActionTriggerSource.AutoFix);
+    }
+}

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

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { registerEditorAction, registerEditorCommand, registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { editorConfigurationBaseNode } from '../../../common/config/editorConfigurationSchema.js';
+import { AutoFixAction, CodeActionCommand, FixAllAction, OrganizeImportsAction, QuickFixAction, RefactorAction, SourceAction } from './codeActionCommands.js';
+import { CodeActionController } from './codeActionController.js';
+import { LightBulbWidget } from './lightBulbWidget.js';
+import * as nls from '../../../../nls.js';
+import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+registerEditorContribution(CodeActionController.ID, CodeActionController, 3 /* EditorContributionInstantiation.Eventually */);
+registerEditorContribution(LightBulbWidget.ID, LightBulbWidget, 4 /* EditorContributionInstantiation.Lazy */);
+registerEditorAction(QuickFixAction);
+registerEditorAction(RefactorAction);
+registerEditorAction(SourceAction);
+registerEditorAction(OrganizeImportsAction);
+registerEditorAction(AutoFixAction);
+registerEditorAction(FixAllAction);
+registerEditorCommand(new CodeActionCommand());
+Registry.as(Extensions.Configuration).registerConfiguration({
+    ...editorConfigurationBaseNode,
+    properties: {
+        'editor.codeActionWidget.showHeaders': {
+            type: 'boolean',
+            scope: 5 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */,
+            description: nls.localize('showCodeActionHeaders', "Enable/disable showing group headers in the Code Action menu."),
+            default: true,
+        },
+    }
+});
+Registry.as(Extensions.Configuration).registerConfiguration({
+    ...editorConfigurationBaseNode,
+    properties: {
+        'editor.codeActionWidget.includeNearbyQuickFixes': {
+            type: 'boolean',
+            scope: 5 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */,
+            description: nls.localize('includeNearbyQuickFixes', "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."),
+            default: true,
+        },
+    }
+});