claude-flow-novice 2.3.1 → 2.3.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/common/tokens/contiguousTokensEditing.js

@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { LineTokens } from './lineTokens.js';
+export const EMPTY_LINE_TOKENS = (new Uint32Array(0)).buffer;
+export class ContiguousTokensEditing {
+    static deleteBeginning(lineTokens, toChIndex) {
+        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {
+            return lineTokens;
+        }
+        return ContiguousTokensEditing.delete(lineTokens, 0, toChIndex);
+    }
+    static deleteEnding(lineTokens, fromChIndex) {
+        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {
+            return lineTokens;
+        }
+        const tokens = toUint32Array(lineTokens);
+        const lineTextLength = tokens[tokens.length - 2];
+        return ContiguousTokensEditing.delete(lineTokens, fromChIndex, lineTextLength);
+    }
+    static delete(lineTokens, fromChIndex, toChIndex) {
+        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS || fromChIndex === toChIndex) {
+            return lineTokens;
+        }
+        const tokens = toUint32Array(lineTokens);
+        const tokensCount = (tokens.length >>> 1);
+        // special case: deleting everything
+        if (fromChIndex === 0 && tokens[tokens.length - 2] === toChIndex) {
+            return EMPTY_LINE_TOKENS;
+        }
+        const fromTokenIndex = LineTokens.findIndexInTokensArray(tokens, fromChIndex);
+        const fromTokenStartOffset = (fromTokenIndex > 0 ? tokens[(fromTokenIndex - 1) << 1] : 0);
+        const fromTokenEndOffset = tokens[fromTokenIndex << 1];
+        if (toChIndex < fromTokenEndOffset) {
+            // the delete range is inside a single token
+            const delta = (toChIndex - fromChIndex);
+            for (let i = fromTokenIndex; i < tokensCount; i++) {
+                tokens[i << 1] -= delta;
+            }
+            return lineTokens;
+        }
+        let dest;
+        let lastEnd;
+        if (fromTokenStartOffset !== fromChIndex) {
+            tokens[fromTokenIndex << 1] = fromChIndex;
+            dest = ((fromTokenIndex + 1) << 1);
+            lastEnd = fromChIndex;
+        }
+        else {
+            dest = (fromTokenIndex << 1);
+            lastEnd = fromTokenStartOffset;
+        }
+        const delta = (toChIndex - fromChIndex);
+        for (let tokenIndex = fromTokenIndex + 1; tokenIndex < tokensCount; tokenIndex++) {
+            const tokenEndOffset = tokens[tokenIndex << 1] - delta;
+            if (tokenEndOffset > lastEnd) {
+                tokens[dest++] = tokenEndOffset;
+                tokens[dest++] = tokens[(tokenIndex << 1) + 1];
+                lastEnd = tokenEndOffset;
+            }
+        }
+        if (dest === tokens.length) {
+            // nothing to trim
+            return lineTokens;
+        }
+        const tmp = new Uint32Array(dest);
+        tmp.set(tokens.subarray(0, dest), 0);
+        return tmp.buffer;
+    }
+    static append(lineTokens, _otherTokens) {
+        if (_otherTokens === EMPTY_LINE_TOKENS) {
+            return lineTokens;
+        }
+        if (lineTokens === EMPTY_LINE_TOKENS) {
+            return _otherTokens;
+        }
+        if (lineTokens === null) {
+            return lineTokens;
+        }
+        if (_otherTokens === null) {
+            // cannot determine combined line length...
+            return null;
+        }
+        const myTokens = toUint32Array(lineTokens);
+        const otherTokens = toUint32Array(_otherTokens);
+        const otherTokensCount = (otherTokens.length >>> 1);
+        const result = new Uint32Array(myTokens.length + otherTokens.length);
+        result.set(myTokens, 0);
+        let dest = myTokens.length;
+        const delta = myTokens[myTokens.length - 2];
+        for (let i = 0; i < otherTokensCount; i++) {
+            result[dest++] = otherTokens[(i << 1)] + delta;
+            result[dest++] = otherTokens[(i << 1) + 1];
+        }
+        return result.buffer;
+    }
+    static insert(lineTokens, chIndex, textLength) {
+        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {
+            // nothing to do
+            return lineTokens;
+        }
+        const tokens = toUint32Array(lineTokens);
+        const tokensCount = (tokens.length >>> 1);
+        let fromTokenIndex = LineTokens.findIndexInTokensArray(tokens, chIndex);
+        if (fromTokenIndex > 0) {
+            const fromTokenStartOffset = tokens[(fromTokenIndex - 1) << 1];
+            if (fromTokenStartOffset === chIndex) {
+                fromTokenIndex--;
+            }
+        }
+        for (let tokenIndex = fromTokenIndex; tokenIndex < tokensCount; tokenIndex++) {
+            tokens[tokenIndex << 1] += textLength;
+        }
+        return lineTokens;
+    }
+}
+export function toUint32Array(arr) {
+    if (arr instanceof Uint32Array) {
+        return arr;
+    }
+    else {
+        return new Uint32Array(arr);
+    }
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/common/tokens/contiguousTokensStore.js

@@ -0,0 +1,204 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as arrays from '../../../base/common/arrays.js';
+import { Position } from '../core/position.js';
+import { ContiguousTokensEditing, EMPTY_LINE_TOKENS, toUint32Array } from './contiguousTokensEditing.js';
+import { LineTokens } from './lineTokens.js';
+import { TokenMetadata } from '../encodedTokenAttributes.js';
+/**
+ * Represents contiguous tokens in a text model.
+ */
+export class ContiguousTokensStore {
+    constructor(languageIdCodec) {
+        this._lineTokens = [];
+        this._len = 0;
+        this._languageIdCodec = languageIdCodec;
+    }
+    flush() {
+        this._lineTokens = [];
+        this._len = 0;
+    }
+    get hasTokens() {
+        return this._lineTokens.length > 0;
+    }
+    getTokens(topLevelLanguageId, lineIndex, lineText) {
+        let rawLineTokens = null;
+        if (lineIndex < this._len) {
+            rawLineTokens = this._lineTokens[lineIndex];
+        }
+        if (rawLineTokens !== null && rawLineTokens !== EMPTY_LINE_TOKENS) {
+            return new LineTokens(toUint32Array(rawLineTokens), lineText, this._languageIdCodec);
+        }
+        const lineTokens = new Uint32Array(2);
+        lineTokens[0] = lineText.length;
+        lineTokens[1] = getDefaultMetadata(this._languageIdCodec.encodeLanguageId(topLevelLanguageId));
+        return new LineTokens(lineTokens, lineText, this._languageIdCodec);
+    }
+    static _massageTokens(topLevelLanguageId, lineTextLength, _tokens) {
+        const tokens = _tokens ? toUint32Array(_tokens) : null;
+        if (lineTextLength === 0) {
+            let hasDifferentLanguageId = false;
+            if (tokens && tokens.length > 1) {
+                hasDifferentLanguageId = (TokenMetadata.getLanguageId(tokens[1]) !== topLevelLanguageId);
+            }
+            if (!hasDifferentLanguageId) {
+                return EMPTY_LINE_TOKENS;
+            }
+        }
+        if (!tokens || tokens.length === 0) {
+            const tokens = new Uint32Array(2);
+            tokens[0] = lineTextLength;
+            tokens[1] = getDefaultMetadata(topLevelLanguageId);
+            return tokens.buffer;
+        }
+        // Ensure the last token covers the end of the text
+        tokens[tokens.length - 2] = lineTextLength;
+        if (tokens.byteOffset === 0 && tokens.byteLength === tokens.buffer.byteLength) {
+            // Store directly the ArrayBuffer pointer to save an object
+            return tokens.buffer;
+        }
+        return tokens;
+    }
+    _ensureLine(lineIndex) {
+        while (lineIndex >= this._len) {
+            this._lineTokens[this._len] = null;
+            this._len++;
+        }
+    }
+    _deleteLines(start, deleteCount) {
+        if (deleteCount === 0) {
+            return;
+        }
+        if (start + deleteCount > this._len) {
+            deleteCount = this._len - start;
+        }
+        this._lineTokens.splice(start, deleteCount);
+        this._len -= deleteCount;
+    }
+    _insertLines(insertIndex, insertCount) {
+        if (insertCount === 0) {
+            return;
+        }
+        const lineTokens = [];
+        for (let i = 0; i < insertCount; i++) {
+            lineTokens[i] = null;
+        }
+        this._lineTokens = arrays.arrayInsert(this._lineTokens, insertIndex, lineTokens);
+        this._len += insertCount;
+    }
+    setTokens(topLevelLanguageId, lineIndex, lineTextLength, _tokens, checkEquality) {
+        const tokens = ContiguousTokensStore._massageTokens(this._languageIdCodec.encodeLanguageId(topLevelLanguageId), lineTextLength, _tokens);
+        this._ensureLine(lineIndex);
+        const oldTokens = this._lineTokens[lineIndex];
+        this._lineTokens[lineIndex] = tokens;
+        if (checkEquality) {
+            return !ContiguousTokensStore._equals(oldTokens, tokens);
+        }
+        return false;
+    }
+    static _equals(_a, _b) {
+        if (!_a || !_b) {
+            return !_a && !_b;
+        }
+        const a = toUint32Array(_a);
+        const b = toUint32Array(_b);
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0, len = a.length; i < len; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    //#region Editing
+    acceptEdit(range, eolCount, firstLineLength) {
+        this._acceptDeleteRange(range);
+        this._acceptInsertText(new Position(range.startLineNumber, range.startColumn), eolCount, firstLineLength);
+    }
+    _acceptDeleteRange(range) {
+        const firstLineIndex = range.startLineNumber - 1;
+        if (firstLineIndex >= this._len) {
+            return;
+        }
+        if (range.startLineNumber === range.endLineNumber) {
+            if (range.startColumn === range.endColumn) {
+                // Nothing to delete
+                return;
+            }
+            this._lineTokens[firstLineIndex] = ContiguousTokensEditing.delete(this._lineTokens[firstLineIndex], range.startColumn - 1, range.endColumn - 1);
+            return;
+        }
+        this._lineTokens[firstLineIndex] = ContiguousTokensEditing.deleteEnding(this._lineTokens[firstLineIndex], range.startColumn - 1);
+        const lastLineIndex = range.endLineNumber - 1;
+        let lastLineTokens = null;
+        if (lastLineIndex < this._len) {
+            lastLineTokens = ContiguousTokensEditing.deleteBeginning(this._lineTokens[lastLineIndex], range.endColumn - 1);
+        }
+        // Take remaining text on last line and append it to remaining text on first line
+        this._lineTokens[firstLineIndex] = ContiguousTokensEditing.append(this._lineTokens[firstLineIndex], lastLineTokens);
+        // Delete middle lines
+        this._deleteLines(range.startLineNumber, range.endLineNumber - range.startLineNumber);
+    }
+    _acceptInsertText(position, eolCount, firstLineLength) {
+        if (eolCount === 0 && firstLineLength === 0) {
+            // Nothing to insert
+            return;
+        }
+        const lineIndex = position.lineNumber - 1;
+        if (lineIndex >= this._len) {
+            return;
+        }
+        if (eolCount === 0) {
+            // Inserting text on one line
+            this._lineTokens[lineIndex] = ContiguousTokensEditing.insert(this._lineTokens[lineIndex], position.column - 1, firstLineLength);
+            return;
+        }
+        this._lineTokens[lineIndex] = ContiguousTokensEditing.deleteEnding(this._lineTokens[lineIndex], position.column - 1);
+        this._lineTokens[lineIndex] = ContiguousTokensEditing.insert(this._lineTokens[lineIndex], position.column - 1, firstLineLength);
+        this._insertLines(position.lineNumber, eolCount);
+    }
+    //#endregion
+    setMultilineTokens(tokens, textModel) {
+        if (tokens.length === 0) {
+            return { changes: [] };
+        }
+        const ranges = [];
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const element = tokens[i];
+            let minChangedLineNumber = 0;
+            let maxChangedLineNumber = 0;
+            let hasChange = false;
+            for (let lineNumber = element.startLineNumber; lineNumber <= element.endLineNumber; lineNumber++) {
+                if (hasChange) {
+                    this.setTokens(textModel.getLanguageId(), lineNumber - 1, textModel.getLineLength(lineNumber), element.getLineTokens(lineNumber), false);
+                    maxChangedLineNumber = lineNumber;
+                }
+                else {
+                    const lineHasChange = this.setTokens(textModel.getLanguageId(), lineNumber - 1, textModel.getLineLength(lineNumber), element.getLineTokens(lineNumber), true);
+                    if (lineHasChange) {
+                        hasChange = true;
+                        minChangedLineNumber = lineNumber;
+                        maxChangedLineNumber = lineNumber;
+                    }
+                }
+            }
+            if (hasChange) {
+                ranges.push({ fromLineNumber: minChangedLineNumber, toLineNumber: maxChangedLineNumber, });
+            }
+        }
+        return { changes: ranges };
+    }
+}
+function getDefaultMetadata(topLevelLanguageId) {
+    return ((topLevelLanguageId << 0 /* MetadataConsts.LANGUAGEID_OFFSET */)
+        | (0 /* StandardTokenType.Other */ << 8 /* MetadataConsts.TOKEN_TYPE_OFFSET */)
+        | (0 /* FontStyle.None */ << 11 /* MetadataConsts.FONT_STYLE_OFFSET */)
+        | (1 /* ColorId.DefaultForeground */ << 15 /* MetadataConsts.FOREGROUND_OFFSET */)
+        | (2 /* ColorId.DefaultBackground */ << 24 /* MetadataConsts.BACKGROUND_OFFSET */)
+        // If there is no grammar, we just take a guess and try to match brackets.
+        | (1024 /* MetadataConsts.BALANCED_BRACKETS_MASK */)) >>> 0;
+}

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

@@ -0,0 +1,164 @@
+/*---------------------------------------------------------------------------------------------
+ *  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); }
+};
+var SelectionAnchorController_1;
+import { alert } from '../../../../base/browser/ui/aria/aria.js';
+import { MarkdownString } from '../../../../base/common/htmlContent.js';
+import { KeyChord } from '../../../../base/common/keyCodes.js';
+import './anchorSelect.css';
+import { EditorAction, registerEditorAction, registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { Selection } from '../../../common/core/selection.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { localize } from '../../../../nls.js';
+import { IContextKeyService, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+export const SelectionAnchorSet = new RawContextKey('selectionAnchorSet', false);
+let SelectionAnchorController = SelectionAnchorController_1 = class SelectionAnchorController {
+    static get(editor) {
+        return editor.getContribution(SelectionAnchorController_1.ID);
+    }
+    constructor(editor, contextKeyService) {
+        this.editor = editor;
+        this.selectionAnchorSetContextKey = SelectionAnchorSet.bindTo(contextKeyService);
+        this.modelChangeListener = editor.onDidChangeModel(() => this.selectionAnchorSetContextKey.reset());
+    }
+    setSelectionAnchor() {
+        if (this.editor.hasModel()) {
+            const position = this.editor.getPosition();
+            this.editor.changeDecorations((accessor) => {
+                if (this.decorationId) {
+                    accessor.removeDecoration(this.decorationId);
+                }
+                this.decorationId = accessor.addDecoration(Selection.fromPositions(position, position), {
+                    description: 'selection-anchor',
+                    stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+                    hoverMessage: new MarkdownString().appendText(localize('selectionAnchor', "Selection Anchor")),
+                    className: 'selection-anchor'
+                });
+            });
+            this.selectionAnchorSetContextKey.set(!!this.decorationId);
+            alert(localize('anchorSet', "Anchor set at {0}:{1}", position.lineNumber, position.column));
+        }
+    }
+    goToSelectionAnchor() {
+        if (this.editor.hasModel() && this.decorationId) {
+            const anchorPosition = this.editor.getModel().getDecorationRange(this.decorationId);
+            if (anchorPosition) {
+                this.editor.setPosition(anchorPosition.getStartPosition());
+            }
+        }
+    }
+    selectFromAnchorToCursor() {
+        if (this.editor.hasModel() && this.decorationId) {
+            const start = this.editor.getModel().getDecorationRange(this.decorationId);
+            if (start) {
+                const end = this.editor.getPosition();
+                this.editor.setSelection(Selection.fromPositions(start.getStartPosition(), end));
+                this.cancelSelectionAnchor();
+            }
+        }
+    }
+    cancelSelectionAnchor() {
+        if (this.decorationId) {
+            const decorationId = this.decorationId;
+            this.editor.changeDecorations((accessor) => {
+                accessor.removeDecoration(decorationId);
+                this.decorationId = undefined;
+            });
+            this.selectionAnchorSetContextKey.set(false);
+        }
+    }
+    dispose() {
+        this.cancelSelectionAnchor();
+        this.modelChangeListener.dispose();
+    }
+};
+SelectionAnchorController.ID = 'editor.contrib.selectionAnchorController';
+SelectionAnchorController = SelectionAnchorController_1 = __decorate([
+    __param(1, IContextKeyService)
+], SelectionAnchorController);
+class SetSelectionAnchor extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.setSelectionAnchor',
+            label: localize('setSelectionAnchor', "Set Selection Anchor"),
+            alias: 'Set Selection Anchor',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 32 /* KeyCode.KeyB */),
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    async run(_accessor, editor) {
+        var _a;
+        (_a = SelectionAnchorController.get(editor)) === null || _a === void 0 ? void 0 : _a.setSelectionAnchor();
+    }
+}
+class GoToSelectionAnchor extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.goToSelectionAnchor',
+            label: localize('goToSelectionAnchor', "Go to Selection Anchor"),
+            alias: 'Go to Selection Anchor',
+            precondition: SelectionAnchorSet,
+        });
+    }
+    async run(_accessor, editor) {
+        var _a;
+        (_a = SelectionAnchorController.get(editor)) === null || _a === void 0 ? void 0 : _a.goToSelectionAnchor();
+    }
+}
+class SelectFromAnchorToCursor extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.selectFromAnchorToCursor',
+            label: localize('selectFromAnchorToCursor', "Select from Anchor to Cursor"),
+            alias: 'Select from Anchor to Cursor',
+            precondition: SelectionAnchorSet,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */),
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    async run(_accessor, editor) {
+        var _a;
+        (_a = SelectionAnchorController.get(editor)) === null || _a === void 0 ? void 0 : _a.selectFromAnchorToCursor();
+    }
+}
+class CancelSelectionAnchor extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.cancelSelectionAnchor',
+            label: localize('cancelSelectionAnchor', "Cancel Selection Anchor"),
+            alias: 'Cancel Selection Anchor',
+            precondition: SelectionAnchorSet,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 9 /* KeyCode.Escape */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    async run(_accessor, editor) {
+        var _a;
+        (_a = SelectionAnchorController.get(editor)) === null || _a === void 0 ? void 0 : _a.cancelSelectionAnchor();
+    }
+}
+registerEditorContribution(SelectionAnchorController.ID, SelectionAnchorController, 4 /* EditorContributionInstantiation.Lazy */);
+registerEditorAction(SetSelectionAnchor);
+registerEditorAction(GoToSelectionAnchor);
+registerEditorAction(SelectFromAnchorToCursor);
+registerEditorAction(CancelSelectionAnchor);