@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/chat/common/chatRequestParser.js

@@ -0,0 +1,193 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { OffsetRange } from 'monaco-editor/esm/vs/editor/common/core/offsetRange.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { IChatAgentService } from './chatAgents.js';
+import { chatVariableLeader, chatAgentLeader, chatSubcommandLeader, ChatRequestTextPart, ChatRequestAgentPart, ChatRequestVariablePart, ChatRequestSlashCommandPart, ChatRequestAgentSubcommandPart, ChatRequestDynamicVariablePart } from './chatParserTypes.js';
+import { IChatSlashCommandService } from './chatSlashCommands.js';
+import { IChatVariablesService } from './chatVariables.js';
+const agentReg = /^@([\w_\-]+)(?=(\s|$|\b))/i;
+const variableReg = /^#([\w_\-]+)(:\d+)?(?=(\s|$|\b))/i;
+const slashReg = /\/([\w_\-]+)(?=(\s|$|\b))/i;
+let ChatRequestParser = class ChatRequestParser {
+    constructor(agentService, variableService, slashCommandService) {
+        this.agentService = agentService;
+        this.variableService = variableService;
+        this.slashCommandService = slashCommandService;
+    }
+    async parseChatRequest(sessionId, message) {
+        const parts = [];
+        const references = this.variableService.getDynamicVariables(sessionId);
+        let lineNumber = 1;
+        let column = 1;
+        for (let i = 0; i < message.length; i++) {
+            const previousChar = message.charAt(i - 1);
+            const char = message.charAt(i);
+            let newPart;
+            if (previousChar.match(/\s/) || i === 0) {
+                if (char === chatVariableLeader) {
+                    newPart = this.tryToParseVariable(message.slice(i), i, ( new Position(lineNumber, column)), parts);
+                }
+                else if (char === chatAgentLeader) {
+                    newPart = this.tryToParseAgent(message.slice(i), message, i, ( new Position(lineNumber, column)), parts);
+                }
+                else if (char === chatSubcommandLeader) {
+                    newPart = await this.tryToParseSlashCommand(sessionId, message.slice(i), message, i, ( new Position(lineNumber, column)), parts);
+                }
+                if (!newPart) {
+                    newPart = this.tryToParseDynamicVariable(message.slice(i), i, ( new Position(lineNumber, column)), references);
+                }
+            }
+            if (newPart) {
+                if (i !== 0) {
+                    const previousPart = parts.at(-1);
+                    const previousPartEnd = previousPart?.range.endExclusive ?? 0;
+                    const previousPartEditorRangeEndLine = previousPart?.editorRange.endLineNumber ?? 1;
+                    const previousPartEditorRangeEndCol = previousPart?.editorRange.endColumn ?? 1;
+                    parts.push(( new ChatRequestTextPart(( new OffsetRange(previousPartEnd, i)), ( new Range(
+                        previousPartEditorRangeEndLine,
+                        previousPartEditorRangeEndCol,
+                        lineNumber,
+                        column
+                    )), message.slice(previousPartEnd, i))));
+                }
+                parts.push(newPart);
+            }
+            if (char === '\n') {
+                lineNumber++;
+                column = 1;
+            }
+            else {
+                column++;
+            }
+        }
+        const lastPart = parts.at(-1);
+        const lastPartEnd = lastPart?.range.endExclusive ?? 0;
+        if (lastPartEnd < message.length) {
+            parts.push(( new ChatRequestTextPart(( new OffsetRange(lastPartEnd, message.length)), ( new Range(
+                lastPart?.editorRange.endLineNumber ?? 1,
+                lastPart?.editorRange.endColumn ?? 1,
+                lineNumber,
+                column
+            )), message.slice(lastPartEnd, message.length))));
+        }
+        return {
+            parts,
+            text: message,
+        };
+    }
+    tryToParseAgent(message, fullMessage, offset, position, parts) {
+        const nextVariableMatch = message.match(agentReg);
+        if (!nextVariableMatch) {
+            return;
+        }
+        const [full, name] = nextVariableMatch;
+        const varRange = ( new OffsetRange(offset, offset + full.length));
+        const varEditorRange = ( new Range(
+            position.lineNumber,
+            position.column,
+            position.lineNumber,
+            position.column + full.length
+        ));
+        const agent = this.agentService.getAgent(name);
+        if (!agent) {
+            return;
+        }
+        if (( parts.some(p => p instanceof ChatRequestAgentPart))) {
+            return;
+        }
+        if (( parts.some(
+            p => (p instanceof ChatRequestTextPart && p.text.trim() !== '') || !(p instanceof ChatRequestAgentPart)
+        ))) {
+            return;
+        }
+        const previousPart = parts.at(-1);
+        const previousPartEnd = previousPart?.range.endExclusive ?? 0;
+        const textSincePreviousPart = fullMessage.slice(previousPartEnd, offset);
+        if (textSincePreviousPart.trim() !== '') {
+            return;
+        }
+        return ( new ChatRequestAgentPart(varRange, varEditorRange, agent));
+    }
+    tryToParseVariable(message, offset, position, parts) {
+        const nextVariableMatch = message.match(variableReg);
+        if (!nextVariableMatch) {
+            return;
+        }
+        const [full, name] = nextVariableMatch;
+        const variableArg = nextVariableMatch[2] ?? '';
+        const varRange = ( new OffsetRange(offset, offset + full.length));
+        const varEditorRange = ( new Range(
+            position.lineNumber,
+            position.column,
+            position.lineNumber,
+            position.column + full.length
+        ));
+        if (this.variableService.hasVariable(name)) {
+            return ( new ChatRequestVariablePart(varRange, varEditorRange, name, variableArg));
+        }
+        return;
+    }
+    async tryToParseSlashCommand(sessionId, remainingMessage, fullMessage, offset, position, parts) {
+        const nextSlashMatch = remainingMessage.match(slashReg);
+        if (!nextSlashMatch) {
+            return;
+        }
+        if (( parts.some(p => p instanceof ChatRequestSlashCommandPart))) {
+            return;
+        }
+        const [full, command] = nextSlashMatch;
+        const slashRange = ( new OffsetRange(offset, offset + full.length));
+        const slashEditorRange = ( new Range(
+            position.lineNumber,
+            position.column,
+            position.lineNumber,
+            position.column + full.length
+        ));
+        const usedAgent = parts.find((p) => p instanceof ChatRequestAgentPart);
+        if (usedAgent) {
+            if (( parts.some(
+                p => (p instanceof ChatRequestTextPart && p.text.trim() !== '') || !(p instanceof ChatRequestAgentPart) && !(p instanceof ChatRequestTextPart)
+            ))) {
+                return;
+            }
+            const previousPart = parts.at(-1);
+            const previousPartEnd = previousPart?.range.endExclusive ?? 0;
+            const textSincePreviousPart = fullMessage.slice(previousPartEnd, offset);
+            if (textSincePreviousPart.trim() !== '') {
+                return;
+            }
+            const subCommands = await usedAgent.agent.provideSlashCommands(CancellationToken.None);
+            const subCommand = subCommands.find(c => c.name === command);
+            if (subCommand) {
+                return ( new ChatRequestAgentSubcommandPart(slashRange, slashEditorRange, subCommand));
+            }
+        }
+        else {
+            const slashCommands = this.slashCommandService.getCommands();
+            const slashCommand = slashCommands.find(c => c.command === command);
+            if (slashCommand) {
+                return ( new ChatRequestSlashCommandPart(slashRange, slashEditorRange, slashCommand));
+            }
+        }
+        return;
+    }
+    tryToParseDynamicVariable(message, offset, position, references) {
+        const refAtThisPosition = references.find(r => r.range.startLineNumber === position.lineNumber &&
+            r.range.startColumn === position.column);
+        if (refAtThisPosition) {
+            const length = refAtThisPosition.range.endColumn - refAtThisPosition.range.startColumn;
+            const text = message.substring(0, length);
+            const range = ( new OffsetRange(offset, offset + length));
+            return ( new ChatRequestDynamicVariablePart(range, refAtThisPosition.range, text, refAtThisPosition.data));
+        }
+        return;
+    }
+};
+ChatRequestParser = ( __decorate([
+    ( __param(0, IChatAgentService)),
+    ( __param(1, IChatVariablesService)),
+    ( __param(2, IChatSlashCommandService))
+], ChatRequestParser));
+export { ChatRequestParser };

package/vscode/src/vs/workbench/contrib/chat/common/chatService.js

@@ -1,8 +1,29 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+function isIDocumentContext(obj) {
+    return (!!obj &&
+        typeof obj === 'object' &&
+        'uri' in obj && obj.uri instanceof URI &&
+        'version' in obj && typeof obj.version === 'number' &&
+        'ranges' in obj && Array.isArray(obj.ranges) && obj.ranges.every(Range.isIRange));
+}
+function isIUsedContext(obj) {
+    return (!!obj &&
+        typeof obj === 'object' &&
+        'documents' in obj &&
+        Array.isArray(obj.documents) &&
+        obj.documents.every(isIDocumentContext));
+}
 var InteractiveSessionVoteDirection;
 ( (function(InteractiveSessionVoteDirection) {
     InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Down"] = 0] = "Down";
     InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Up"] = 1] = "Up";
 })(InteractiveSessionVoteDirection || (InteractiveSessionVoteDirection = {})));
+var InteractiveSessionCopyKind;
+( (function(InteractiveSessionCopyKind) {
+    InteractiveSessionCopyKind[InteractiveSessionCopyKind["Action"] = 1] = "Action";
+    InteractiveSessionCopyKind[InteractiveSessionCopyKind["Toolbar"] = 2] = "Toolbar";
+})(InteractiveSessionCopyKind || (InteractiveSessionCopyKind = {})));
 const IChatService = ( createDecorator('IChatService'));
-export { IChatService, InteractiveSessionVoteDirection };
+export { IChatService, InteractiveSessionCopyKind, InteractiveSessionVoteDirection, isIDocumentContext, isIUsedContext };

package/vscode/src/vs/workbench/contrib/chat/common/chatSlashCommands.js

@@ -1,3 +1,54 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
 const IChatSlashCommandService = ( createDecorator('chatSlashCommandService'));
-export { IChatSlashCommandService };
+let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
+    constructor(_extensionService) {
+        super();
+        this._extensionService = _extensionService;
+        this._commands = ( new Map());
+        this._onDidChangeCommands = this._register(( new Emitter()));
+        this.onDidChangeCommands = this._onDidChangeCommands.event;
+    }
+    dispose() {
+        super.dispose();
+        this._commands.clear();
+    }
+    registerSlashCommand(data, command) {
+        if (( this._commands.has(data.command))) {
+            throw new Error(`Already registered a command with id ${data.command}}`);
+        }
+        this._commands.set(data.command, { data, command });
+        this._onDidChangeCommands.fire();
+        return toDisposable(() => {
+            if (this._commands.delete(data.command)) {
+                this._onDidChangeCommands.fire();
+            }
+        });
+    }
+    getCommands() {
+        return Array.from(( this._commands.values()), v => v.data);
+    }
+    hasCommand(id) {
+        return ( this._commands.has(id));
+    }
+    async executeCommand(id, prompt, progress, history, token) {
+        const data = this._commands.get(id);
+        if (!data) {
+            throw new Error('No command with id ${id} NOT registered');
+        }
+        if (!data.command) {
+            await this._extensionService.activateByEvent(`onSlash:${id}`);
+        }
+        if (!data.command) {
+            throw new Error(`No command with id ${id} NOT resolved`);
+        }
+        return await data.command(prompt, progress, history, token);
+    }
+};
+ChatSlashCommandService = ( __decorate([
+    ( __param(0, IExtensionService))
+], ChatSlashCommandService));
+export { ChatSlashCommandService, IChatSlashCommandService };

package/vscode/src/vs/workbench/contrib/chat/common/chatViewModel.js

@@ -0,0 +1,258 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ChatModelInitState } from './chatModel.js';
+import { countWords } from './chatWordCounter.js';
+function isRequestVM(item) {
+    return !!item && typeof item === 'object' && 'message' in item;
+}
+function isResponseVM(item) {
+    return !!item && typeof item.setVote !== 'undefined';
+}
+function isWelcomeVM(item) {
+    return !!item && typeof item === 'object' && 'content' in item;
+}
+let ChatViewModel = class ChatViewModel extends Disposable {
+    get inputPlaceholder() {
+        return this._inputPlaceholder ?? this._model.inputPlaceholder;
+    }
+    setInputPlaceholder(text) {
+        this._inputPlaceholder = text;
+        this._onDidChange.fire({ kind: 'changePlaceholder' });
+    }
+    resetInputPlaceholder() {
+        this._inputPlaceholder = undefined;
+        this._onDidChange.fire({ kind: 'changePlaceholder' });
+    }
+    get sessionId() {
+        return this._model.sessionId;
+    }
+    get requestInProgress() {
+        return this._model.requestInProgress;
+    }
+    get providerId() {
+        return this._model.providerId;
+    }
+    get initState() {
+        return this._model.initState;
+    }
+    constructor(_model, instantiationService) {
+        super();
+        this._model = _model;
+        this.instantiationService = instantiationService;
+        this._onDidDisposeModel = this._register(( new Emitter()));
+        this.onDidDisposeModel = this._onDidDisposeModel.event;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._items = [];
+        this._inputPlaceholder = undefined;
+        _model.getRequests().forEach((request, i) => {
+            this._items.push(( new ChatRequestViewModel(request)));
+            if (request.response) {
+                this.onAddResponse(request.response);
+            }
+        });
+        this._register(_model.onDidDispose(() => this._onDidDisposeModel.fire()));
+        this._register(_model.onDidChange(e => {
+            if (e.kind === 'addRequest') {
+                this._items.push(( new ChatRequestViewModel(e.request)));
+                if (e.request.response) {
+                    this.onAddResponse(e.request.response);
+                }
+            }
+            else if (e.kind === 'addResponse') {
+                this.onAddResponse(e.response);
+            }
+            else if (e.kind === 'removeRequest') {
+                const requestIdx = this._items.findIndex(item => isRequestVM(item) && item.id === e.requestId);
+                if (requestIdx >= 0) {
+                    this._items.splice(requestIdx, 1);
+                }
+                const responseIdx = e.responseId && this._items.findIndex(item => isResponseVM(item) && item.id === e.responseId);
+                if (typeof responseIdx === 'number' && responseIdx >= 0) {
+                    const items = this._items.splice(responseIdx, 1);
+                    const item = items[0];
+                    if (isResponseVM(item)) {
+                        item.dispose();
+                    }
+                }
+            }
+            const modelEventToVmEvent = e.kind === 'addRequest' ? { kind: 'addRequest' } :
+                e.kind === 'initialize' ? { kind: 'initialize' } :
+                    null;
+            this._onDidChange.fire(modelEventToVmEvent);
+        }));
+    }
+    onAddResponse(responseModel) {
+        const response = this.instantiationService.createInstance(ChatResponseViewModel, responseModel);
+        this._register(response.onDidChange(() => this._onDidChange.fire(null)));
+        this._items.push(response);
+    }
+    getItems() {
+        return [...(this._model.welcomeMessage ? [this._model.welcomeMessage] : []), ...this._items];
+    }
+    dispose() {
+        super.dispose();
+        this._items
+            .filter((item) => item instanceof ChatResponseViewModel)
+            .forEach((item) => item.dispose());
+    }
+};
+ChatViewModel = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ChatViewModel));
+class ChatRequestViewModel {
+    get id() {
+        return this._model.id;
+    }
+    get dataId() {
+        return this.id + `_${ChatModelInitState[this._model.session.initState]}`;
+    }
+    get sessionId() {
+        return this._model.session.sessionId;
+    }
+    get username() {
+        return this._model.username;
+    }
+    get avatarIconUri() {
+        return this._model.avatarIconUri;
+    }
+    get message() {
+        return this._model.message;
+    }
+    get messageText() {
+        return 'kind' in this.message ? this.message.message : this.message.text;
+    }
+    constructor(_model) {
+        this._model = _model;
+    }
+}
+let ChatResponseViewModel = class ChatResponseViewModel extends Disposable {
+    get id() {
+        return this._model.id;
+    }
+    get dataId() {
+        return this._model.id + `_${this._modelChangeCount}` + `_${ChatModelInitState[this._model.session.initState]}`;
+    }
+    get providerId() {
+        return this._model.providerId;
+    }
+    get sessionId() {
+        return this._model.session.sessionId;
+    }
+    get username() {
+        return this._model.username;
+    }
+    get avatarIconUri() {
+        return this._model.avatarIconUri;
+    }
+    get agent() {
+        return this._model.agent;
+    }
+    get slashCommand() {
+        return this._model.slashCommand;
+    }
+    get response() {
+        return this._model.response;
+    }
+    get usedContext() {
+        return this._model.usedContext;
+    }
+    get contentReferences() {
+        return this._model.contentReferences;
+    }
+    get progressMessages() {
+        return this._model.progressMessages;
+    }
+    get isComplete() {
+        return this._model.isComplete;
+    }
+    get isCanceled() {
+        return this._model.isCanceled;
+    }
+    get replyFollowups() {
+        return this._model.followups?.filter((f) => f.kind === 'reply');
+    }
+    get commandFollowups() {
+        return this._model.followups?.filter((f) => f.kind === 'command');
+    }
+    get errorDetails() {
+        return this._model.errorDetails;
+    }
+    get vote() {
+        return this._model.vote;
+    }
+    get requestId() {
+        return this._model.requestId;
+    }
+    get usedReferencesExpanded() {
+        if (typeof this._usedReferencesExpanded === 'boolean') {
+            return this._usedReferencesExpanded;
+        }
+        return this.response.value.length === 0;
+    }
+    set usedReferencesExpanded(v) {
+        this._usedReferencesExpanded = v;
+    }
+    get vulnerabilitiesListExpanded() {
+        return this._vulnerabilitiesListExpanded;
+    }
+    set vulnerabilitiesListExpanded(v) {
+        this._vulnerabilitiesListExpanded = v;
+    }
+    get contentUpdateTimings() {
+        return this._contentUpdateTimings;
+    }
+    constructor(_model, logService) {
+        super();
+        this._model = _model;
+        this.logService = logService;
+        this._modelChangeCount = 0;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.renderData = undefined;
+        this._vulnerabilitiesListExpanded = false;
+        this._contentUpdateTimings = undefined;
+        if (!_model.isComplete) {
+            this._contentUpdateTimings = {
+                loadingStartTime: Date.now(),
+                lastUpdateTime: Date.now(),
+                impliedWordLoadRate: 0,
+                lastWordCount: 0
+            };
+        }
+        this._register(_model.onDidChange(() => {
+            if (this._contentUpdateTimings) {
+                const now = Date.now();
+                const wordCount = countWords(_model.response.asString());
+                const timeDiff = now - this._contentUpdateTimings.loadingStartTime;
+                const impliedWordLoadRate = this._contentUpdateTimings.lastWordCount / (timeDiff / 1000);
+                this.trace('onDidChange', `Update- got ${this._contentUpdateTimings.lastWordCount} words over ${timeDiff}ms = ${impliedWordLoadRate} words/s. ${wordCount} words are now available.`);
+                this._contentUpdateTimings = {
+                    loadingStartTime: this._contentUpdateTimings.loadingStartTime,
+                    lastUpdateTime: now,
+                    impliedWordLoadRate,
+                    lastWordCount: wordCount
+                };
+            }
+            else {
+                this.logService.warn('ChatResponseViewModel#onDidChange: got model update but contentUpdateTimings is not initialized');
+            }
+            this._modelChangeCount++;
+            this._onDidChange.fire();
+        }));
+    }
+    trace(tag, message) {
+        this.logService.trace(`ChatResponseViewModel#${tag}: ${message}`);
+    }
+    setVote(vote) {
+        this._modelChangeCount++;
+        this._model.setVote(vote);
+    }
+};
+ChatResponseViewModel = ( __decorate([
+    ( __param(1, ILogService))
+], ChatResponseViewModel));
+export { ChatRequestViewModel, ChatResponseViewModel, ChatViewModel, isRequestVM, isResponseVM, isWelcomeVM };

package/vscode/src/vs/workbench/contrib/chat/common/chatWidgetHistoryService.js

@@ -0,0 +1,37 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Memento } from '../../../common/memento.js';
+const IChatWidgetHistoryService = ( createDecorator('IChatWidgetHistoryService'));
+let ChatWidgetHistoryService = class ChatWidgetHistoryService {
+    constructor(storageService) {
+        this._onDidClearHistory = ( new Emitter());
+        this.onDidClearHistory = this._onDidClearHistory.event;
+        this.memento = ( new Memento('interactive-session', storageService));
+        const loadedState = this.memento.getMemento(1 , 1 );
+        for (const provider in loadedState.history) {
+            loadedState.history[provider] = ( loadedState.history[provider].map(entry => typeof entry === 'string' ? { text: entry } : entry));
+        }
+        this.viewState = loadedState;
+    }
+    getHistory(providerId) {
+        return this.viewState.history?.[providerId] ?? [];
+    }
+    saveHistory(providerId, history) {
+        if (!this.viewState.history) {
+            this.viewState.history = {};
+        }
+        this.viewState.history[providerId] = history;
+        this.memento.saveMemento();
+    }
+    clearHistory() {
+        this.viewState.history = {};
+        this.memento.saveMemento();
+        this._onDidClearHistory.fire();
+    }
+};
+ChatWidgetHistoryService = ( __decorate([
+    ( __param(0, IStorageService))
+], ChatWidgetHistoryService));
+export { ChatWidgetHistoryService, IChatWidgetHistoryService };

package/vscode/src/vs/workbench/contrib/chat/common/chatWordCounter.js

@@ -0,0 +1,25 @@
+const wordSeparatorCharPattern = /[\s\|\-]/;
+function getNWords(str, numWordsToCount) {
+    let wordCount = numWordsToCount;
+    let i = 0;
+    while (i < str.length && wordCount > 0) {
+        while (i < str.length && str[i].match(wordSeparatorCharPattern)) {
+            i++;
+        }
+        while (i < str.length && !str[i].match(wordSeparatorCharPattern)) {
+            i++;
+        }
+        wordCount--;
+    }
+    const value = str.substring(0, i);
+    return {
+        value,
+        actualWordCount: numWordsToCount - wordCount,
+        isFullString: i >= str.length
+    };
+}
+function countWords(str) {
+    const result = getNWords(str, Number.MAX_SAFE_INTEGER);
+    return result.actualWordCount;
+}
+export { countWords, getNWords };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .simple-find-part-wrapper{max-width:calc(100% - 64px);overflow:hidden;padding:0 10px 10px;pointer-events:none;position:absolute;right:18px;top:0;z-index:10}.simple-find-part .monaco-inputbox>.ibwrapper>input{text-overflow:clip}.monaco-workbench .simple-find-part{align-items:center;background-color:var(--vscode-editorWidget-background)!important;border:1px solid var(--vscode-widget-border);border-bottom-left-radius:4px;border-bottom-right-radius:4px;box-shadow:0 0 8px 2px var(--vscode-widget-shadow);color:var(--vscode-editorWidget-foreground);display:flex;font-size:12px;padding:4px;pointer-events:all;position:relative;top:-45px;transition:top .2s linear;visibility:hidden;z-index:10}.monaco-workbench.reduce-motion .monaco-editor .find-widget{transition:top 0ms linear}.monaco-workbench .simple-find-part.visible{visibility:visible}.monaco-workbench .simple-find-part.suppress-transition{transition:none}.monaco-workbench .simple-find-part.visible-transition{top:0}.monaco-workbench .simple-find-part .monaco-findInput{flex:1}.monaco-workbench .simple-find-part .matchesCount{max-width:73px;min-width:73px;padding-left:5px;width:73px}.monaco-workbench .simple-find-part.reduced-find-widget .matchesCount{display:none}.monaco-workbench .simple-find-part .button{background-position:50%;background-repeat:no-repeat;cursor:pointer;display:flex;flex:initial;height:20px;justify-content:center;line-height:20px;margin-left:3px;min-width:20px;width:20px}.monaco-workbench div.simple-find-part div.button.disabled{cursor:default;opacity:.3!important}div.simple-find-part-wrapper div.button{border-radius:5px}.no-results.matchesCount{color:var(--vscode-errorForeground)}div.simple-find-part-wrapper div.button:hover:not(.disabled){background-color:var(--vscode-toolbar-hoverBackground);outline:1px dashed var(--vscode-toolbar-hoverOutline);outline-offset:-1px}.monaco-workbench .simple-find-part .monaco-sash{border-bottom-left-radius:4px;border-left:1px solid;left:0!important}.monaco-workbench .simple-find-part .monaco-sash.vertical:before{left:calc(50% - var(--vscode-sash-hover-size)/4);width:2px}";
+n(css,{});
+export { css, css as default };