@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/contrib/parameterHints/browser/parameterHints.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .parameter-hints-widget{background-color:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);color:var(--vscode-editorHoverWidget-foreground);cursor:default;display:flex;flex-direction:column;line-height:1.5em;z-index:39}.hc-black .monaco-editor .parameter-hints-widget,.hc-light .monaco-editor .parameter-hints-widget{border-width:2px}.monaco-editor .parameter-hints-widget>.phwrapper{display:flex;flex-direction:row;max-width:440px}.monaco-editor .parameter-hints-widget.multiple{min-height:3.3em;padding:0}.monaco-editor .parameter-hints-widget.multiple .body:before{border-left:1px solid var(--vscode-editorHoverWidget-border);content:\"\";display:block;height:100%;opacity:.5;position:absolute}.monaco-editor .parameter-hints-widget p,.monaco-editor .parameter-hints-widget ul{margin:8px 0}.monaco-editor .parameter-hints-widget .body,.monaco-editor .parameter-hints-widget .monaco-scrollable-element{display:flex;flex:1;flex-direction:column;min-height:100%}.monaco-editor .parameter-hints-widget .signature{padding:4px 5px;position:relative}.monaco-editor .parameter-hints-widget .signature.has-docs:after{border-bottom:1px solid var(--vscode-editorHoverWidget-border);content:\"\";display:block;left:0;opacity:.5;padding-top:4px;position:absolute;width:100%}.monaco-editor .parameter-hints-widget .docs{padding:0 10px 0 5px;white-space:pre-wrap}.monaco-editor .parameter-hints-widget .docs.empty{display:none}.monaco-editor .parameter-hints-widget .docs a{color:var(--vscode-textLink-foreground)}.monaco-editor .parameter-hints-widget .docs a:hover{color:var(--vscode-textLink-activeForeground);cursor:pointer}.monaco-editor .parameter-hints-widget .docs .markdown-docs{white-space:normal}.monaco-editor .parameter-hints-widget .docs code{background-color:var(--vscode-textCodeBlock-background);border-radius:3px;font-family:var(--monaco-monospace-font);padding:0 .4em}.monaco-editor .parameter-hints-widget .docs .code,.monaco-editor .parameter-hints-widget .docs .monaco-tokenized-source{white-space:pre-wrap}.monaco-editor .parameter-hints-widget .controls{align-items:center;display:none;flex-direction:column;justify-content:flex-end;min-width:22px}.monaco-editor .parameter-hints-widget.multiple .controls{display:flex;padding:0 2px}.monaco-editor .parameter-hints-widget.multiple .button{background-repeat:no-repeat;cursor:pointer;height:16px;width:16px}.monaco-editor .parameter-hints-widget .button.previous{bottom:24px}.monaco-editor .parameter-hints-widget .overloads{font-family:var(--monaco-monospace-font);height:12px;line-height:12px;text-align:center}.monaco-editor .parameter-hints-widget .signature .parameter.active{color:var(--vscode-editorHoverWidget-highlightForeground);font-weight:700}.monaco-editor .parameter-hints-widget .documentation-parameter>.parameter{font-weight:700;margin-right:.5em}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/editor/contrib/parameterHints/browser/parameterHints.js

@@ -0,0 +1,119 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Lazy } from '../../../../base/common/lazy.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { registerEditorContribution, registerEditorAction, registerEditorCommand, EditorCommand, EditorAction } from '../../../browser/editorExtensions.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { SignatureHelpTriggerKind } from '../../../common/languages.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { ParameterHintsModel } from './parameterHintsModel.js';
+import { Context } from './provideSignatureHelp.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ParameterHintsWidget } from './parameterHintsWidget.js';
+var ParameterHintsController_1;
+let ParameterHintsController = class ParameterHintsController extends Disposable {
+    static { ParameterHintsController_1 = this; }
+    static { this.ID = 'editor.controller.parameterHints'; }
+    static get(editor) {
+        return editor.getContribution(ParameterHintsController_1.ID);
+    }
+    constructor(editor, instantiationService, languageFeaturesService) {
+        super();
+        this.editor = editor;
+        this.model = this._register(( new ParameterHintsModel(editor, languageFeaturesService.signatureHelpProvider)));
+        this._register(this.model.onChangedHints(newParameterHints => {
+            if (newParameterHints) {
+                this.widget.value.show();
+                this.widget.value.render(newParameterHints);
+            }
+            else {
+                this.widget.rawValue?.hide();
+            }
+        }));
+        this.widget = ( new Lazy(
+            () => this._register(instantiationService.createInstance(ParameterHintsWidget, this.editor, this.model))
+        ));
+    }
+    cancel() {
+        this.model.cancel();
+    }
+    previous() {
+        this.widget.rawValue?.previous();
+    }
+    next() {
+        this.widget.rawValue?.next();
+    }
+    trigger(context) {
+        this.model.trigger(context, 0);
+    }
+};
+ParameterHintsController = ParameterHintsController_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ILanguageFeaturesService))
+], ParameterHintsController));
+class TriggerParameterHintsAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.triggerParameterHints',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/parameterHints/browser/parameterHints',
+                'parameterHints.trigger.label',
+                "Trigger Parameter Hints"
+            )),
+            alias: 'Trigger Parameter Hints',
+            precondition: EditorContextKeys.hasSignatureHelpProvider,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048  | 1024  | 10 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor, editor) {
+        const controller = ParameterHintsController.get(editor);
+        controller?.trigger({
+            triggerKind: SignatureHelpTriggerKind.Invoke
+        });
+    }
+}
+registerEditorContribution(ParameterHintsController.ID, ParameterHintsController, 2 );
+registerEditorAction(TriggerParameterHintsAction);
+const weight = 100  + 75;
+const ParameterHintsCommand = EditorCommand.bindToContribution(ParameterHintsController.get);
+registerEditorCommand(( new ParameterHintsCommand({
+    id: 'closeParameterHints',
+    precondition: Context.Visible,
+    handler: x => x.cancel(),
+    kbOpts: {
+        weight: weight,
+        kbExpr: EditorContextKeys.focus,
+        primary: 9 ,
+        secondary: [1024  | 9 ]
+    }
+})));
+registerEditorCommand(( new ParameterHintsCommand({
+    id: 'showPrevParameterHint',
+    precondition: ( ContextKeyExpr.and(Context.Visible, Context.MultipleSignatures)),
+    handler: x => x.previous(),
+    kbOpts: {
+        weight: weight,
+        kbExpr: EditorContextKeys.focus,
+        primary: 16 ,
+        secondary: [512  | 16 ],
+        mac: { primary: 16 , secondary: [512  | 16 , 256  | 46 ] }
+    }
+})));
+registerEditorCommand(( new ParameterHintsCommand({
+    id: 'showNextParameterHint',
+    precondition: ( ContextKeyExpr.and(Context.Visible, Context.MultipleSignatures)),
+    handler: x => x.next(),
+    kbOpts: {
+        weight: weight,
+        kbExpr: EditorContextKeys.focus,
+        primary: 18 ,
+        secondary: [512  | 18 ],
+        mac: { primary: 18 , secondary: [512  | 18 , 256  | 44 ] }
+    }
+})));
+export { ParameterHintsController, TriggerParameterHintsAction };

package/vscode/src/vs/editor/contrib/parameterHints/browser/parameterHintsModel.js

@@ -0,0 +1,251 @@
+import { Delayer, createCancelablePromise } from '../../../../base/common/async.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { CharacterSet } from '../../../common/core/characterClassifier.js';
+import { SignatureHelpTriggerKind } from '../../../common/languages.js';
+import { provideSignatureHelp } from './provideSignatureHelp.js';
+var ParameterHintState;
+( (function(ParameterHintState) {
+    ( (function(Type) {
+        Type[Type["Default"] = 0] = "Default";
+        Type[Type["Active"] = 1] = "Active";
+        Type[Type["Pending"] = 2] = "Pending";
+    })(ParameterHintState.Type || (ParameterHintState.Type = {})));
+    ParameterHintState.Default = { type: 0  };
+    class Pending {
+        constructor(request, previouslyActiveHints) {
+            this.request = request;
+            this.previouslyActiveHints = previouslyActiveHints;
+            this.type = 2 ;
+        }
+    }
+    ParameterHintState.Pending = Pending;
+    class Active {
+        constructor(hints) {
+            this.hints = hints;
+            this.type = 1 ;
+        }
+    }
+    ParameterHintState.Active = Active;
+})(ParameterHintState || (ParameterHintState = {})));
+class ParameterHintsModel extends Disposable {
+    static { this.DEFAULT_DELAY = 120; }
+    constructor(editor, providers, delay = ParameterHintsModel.DEFAULT_DELAY) {
+        super();
+        this._onChangedHints = this._register(( new Emitter()));
+        this.onChangedHints = this._onChangedHints.event;
+        this.triggerOnType = false;
+        this._state = ParameterHintState.Default;
+        this._pendingTriggers = [];
+        this._lastSignatureHelpResult = this._register(( new MutableDisposable()));
+        this.triggerChars = ( new CharacterSet());
+        this.retriggerChars = ( new CharacterSet());
+        this.triggerId = 0;
+        this.editor = editor;
+        this.providers = providers;
+        this.throttledDelayer = ( new Delayer(delay));
+        this._register(this.editor.onDidBlurEditorWidget(() => this.cancel()));
+        this._register(this.editor.onDidChangeConfiguration(() => this.onEditorConfigurationChange()));
+        this._register(this.editor.onDidChangeModel(e => this.onModelChanged()));
+        this._register(this.editor.onDidChangeModelLanguage(_ => this.onModelChanged()));
+        this._register(this.editor.onDidChangeCursorSelection(e => this.onCursorChange(e)));
+        this._register(this.editor.onDidChangeModelContent(e => this.onModelContentChange()));
+        this._register(this.providers.onDidChange(this.onModelChanged, this));
+        this._register(this.editor.onDidType(text => this.onDidType(text)));
+        this.onEditorConfigurationChange();
+        this.onModelChanged();
+    }
+    get state() { return this._state; }
+    set state(value) {
+        if (this._state.type === 2 ) {
+            this._state.request.cancel();
+        }
+        this._state = value;
+    }
+    cancel(silent = false) {
+        this.state = ParameterHintState.Default;
+        this.throttledDelayer.cancel();
+        if (!silent) {
+            this._onChangedHints.fire(undefined);
+        }
+    }
+    trigger(context, delay) {
+        const model = this.editor.getModel();
+        if (!model || !( this.providers.has(model))) {
+            return;
+        }
+        const triggerId = ++this.triggerId;
+        this._pendingTriggers.push(context);
+        this.throttledDelayer.trigger(() => {
+            return this.doTrigger(triggerId);
+        }, delay)
+            .catch(onUnexpectedError);
+    }
+    next() {
+        if (this.state.type !== 1 ) {
+            return;
+        }
+        const length = this.state.hints.signatures.length;
+        const activeSignature = this.state.hints.activeSignature;
+        const last = (activeSignature % length) === (length - 1);
+        const cycle = this.editor.getOption(85 ).cycle;
+        if ((length < 2 || last) && !cycle) {
+            this.cancel();
+            return;
+        }
+        this.updateActiveSignature(last && cycle ? 0 : activeSignature + 1);
+    }
+    previous() {
+        if (this.state.type !== 1 ) {
+            return;
+        }
+        const length = this.state.hints.signatures.length;
+        const activeSignature = this.state.hints.activeSignature;
+        const first = activeSignature === 0;
+        const cycle = this.editor.getOption(85 ).cycle;
+        if ((length < 2 || first) && !cycle) {
+            this.cancel();
+            return;
+        }
+        this.updateActiveSignature(first && cycle ? length - 1 : activeSignature - 1);
+    }
+    updateActiveSignature(activeSignature) {
+        if (this.state.type !== 1 ) {
+            return;
+        }
+        this.state = new ParameterHintState.Active({ ...this.state.hints, activeSignature });
+        this._onChangedHints.fire(this.state.hints);
+    }
+    async doTrigger(triggerId) {
+        const isRetrigger = this.state.type === 1  || this.state.type === 2 ;
+        const activeSignatureHelp = this.getLastActiveHints();
+        this.cancel(true);
+        if (this._pendingTriggers.length === 0) {
+            return false;
+        }
+        const context = this._pendingTriggers.reduce(mergeTriggerContexts);
+        this._pendingTriggers = [];
+        const triggerContext = {
+            triggerKind: context.triggerKind,
+            triggerCharacter: context.triggerCharacter,
+            isRetrigger: isRetrigger,
+            activeSignatureHelp: activeSignatureHelp
+        };
+        if (!this.editor.hasModel()) {
+            return false;
+        }
+        const model = this.editor.getModel();
+        const position = this.editor.getPosition();
+        this.state = new ParameterHintState.Pending(createCancelablePromise(token => provideSignatureHelp(this.providers, model, position, triggerContext, token)), activeSignatureHelp);
+        try {
+            const result = await this.state.request;
+            if (triggerId !== this.triggerId) {
+                result?.dispose();
+                return false;
+            }
+            if (!result || !result.value.signatures || result.value.signatures.length === 0) {
+                result?.dispose();
+                this._lastSignatureHelpResult.clear();
+                this.cancel();
+                return false;
+            }
+            else {
+                this.state = new ParameterHintState.Active(result.value);
+                this._lastSignatureHelpResult.value = result;
+                this._onChangedHints.fire(this.state.hints);
+                return true;
+            }
+        }
+        catch (error) {
+            if (triggerId === this.triggerId) {
+                this.state = ParameterHintState.Default;
+            }
+            onUnexpectedError(error);
+            return false;
+        }
+    }
+    getLastActiveHints() {
+        switch (this.state.type) {
+            case 1 : return this.state.hints;
+            case 2 : return this.state.previouslyActiveHints;
+            default: return undefined;
+        }
+    }
+    get isTriggered() {
+        return this.state.type === 1
+            || this.state.type === 2
+            || this.throttledDelayer.isTriggered();
+    }
+    onModelChanged() {
+        this.cancel();
+        this.triggerChars.clear();
+        this.retriggerChars.clear();
+        const model = this.editor.getModel();
+        if (!model) {
+            return;
+        }
+        for (const support of this.providers.ordered(model)) {
+            for (const ch of support.signatureHelpTriggerCharacters || []) {
+                if (ch.length) {
+                    const charCode = ch.charCodeAt(0);
+                    this.triggerChars.add(charCode);
+                    this.retriggerChars.add(charCode);
+                }
+            }
+            for (const ch of support.signatureHelpRetriggerCharacters || []) {
+                if (ch.length) {
+                    this.retriggerChars.add(ch.charCodeAt(0));
+                }
+            }
+        }
+    }
+    onDidType(text) {
+        if (!this.triggerOnType) {
+            return;
+        }
+        const lastCharIndex = text.length - 1;
+        const triggerCharCode = text.charCodeAt(lastCharIndex);
+        if (( this.triggerChars.has(triggerCharCode)) || this.isTriggered && ( this.retriggerChars.has(triggerCharCode))) {
+            this.trigger({
+                triggerKind: SignatureHelpTriggerKind.TriggerCharacter,
+                triggerCharacter: text.charAt(lastCharIndex),
+            });
+        }
+    }
+    onCursorChange(e) {
+        if (e.source === 'mouse') {
+            this.cancel();
+        }
+        else if (this.isTriggered) {
+            this.trigger({ triggerKind: SignatureHelpTriggerKind.ContentChange });
+        }
+    }
+    onModelContentChange() {
+        if (this.isTriggered) {
+            this.trigger({ triggerKind: SignatureHelpTriggerKind.ContentChange });
+        }
+    }
+    onEditorConfigurationChange() {
+        this.triggerOnType = this.editor.getOption(85 ).enabled;
+        if (!this.triggerOnType) {
+            this.cancel();
+        }
+    }
+    dispose() {
+        this.cancel(true);
+        super.dispose();
+    }
+}
+function mergeTriggerContexts(previous, current) {
+    switch (current.triggerKind) {
+        case SignatureHelpTriggerKind.Invoke:
+            return current;
+        case SignatureHelpTriggerKind.ContentChange:
+            return previous;
+        case SignatureHelpTriggerKind.TriggerCharacter:
+        default:
+            return current;
+    }
+}
+export { ParameterHintsModel };

package/vscode/src/vs/editor/contrib/parameterHints/browser/parameterHintsWidget.js

@@ -0,0 +1,308 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, addDisposableListener, $ as $$1, EventHelper } from '../../../../base/browser/dom.js';
+import { alert } from '../../../../base/browser/ui/aria/aria.js';
+import { DomScrollableElement } from '../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { assertIsDefined } from '../../../../base/common/types.js';
+import './parameterHints.css.js';
+import { ILanguageService } from '../../../common/languages/language.js';
+import { MarkdownRenderer } from '../../markdownRenderer/browser/markdownRenderer.js';
+import { Context } from './provideSignatureHelp.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { registerColor, listHighlightForeground } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+var ParameterHintsWidget_1;
+const $ = $$1;
+const parameterHintsNextIcon = registerIcon('parameter-hints-next', Codicon.chevronDown, ( localizeWithPath(
+    'vs/editor/contrib/parameterHints/browser/parameterHintsWidget',
+    'parameterHintsNextIcon',
+    'Icon for show next parameter hint.'
+)));
+const parameterHintsPreviousIcon = registerIcon('parameter-hints-previous', Codicon.chevronUp, ( localizeWithPath(
+    'vs/editor/contrib/parameterHints/browser/parameterHintsWidget',
+    'parameterHintsPreviousIcon',
+    'Icon for show previous parameter hint.'
+)));
+let ParameterHintsWidget = class ParameterHintsWidget extends Disposable {
+    static { ParameterHintsWidget_1 = this; }
+    static { this.ID = 'editor.widget.parameterHintsWidget'; }
+    constructor(editor, model, contextKeyService, openerService, languageService) {
+        super();
+        this.editor = editor;
+        this.model = model;
+        this.renderDisposeables = this._register(( new DisposableStore()));
+        this.visible = false;
+        this.announcedLabel = null;
+        this.allowEditorOverflow = true;
+        this.markdownRenderer = this._register(( new MarkdownRenderer({ editor }, languageService, openerService)));
+        this.keyVisible = Context.Visible.bindTo(contextKeyService);
+        this.keyMultipleSignatures = Context.MultipleSignatures.bindTo(contextKeyService);
+    }
+    createParameterHintDOMNodes() {
+        const element = $('.editor-widget.parameter-hints-widget');
+        const wrapper = append(element, $('.phwrapper'));
+        wrapper.tabIndex = -1;
+        const controls = append(wrapper, $('.controls'));
+        const previous = append(controls, $('.button' + ThemeIcon.asCSSSelector(parameterHintsPreviousIcon)));
+        const overloads = append(controls, $('.overloads'));
+        const next = append(controls, $('.button' + ThemeIcon.asCSSSelector(parameterHintsNextIcon)));
+        this._register(addDisposableListener(previous, 'click', e => {
+            EventHelper.stop(e);
+            this.previous();
+        }));
+        this._register(addDisposableListener(next, 'click', e => {
+            EventHelper.stop(e);
+            this.next();
+        }));
+        const body = $('.body');
+        const scrollbar = ( new DomScrollableElement(body, {
+            alwaysConsumeMouseWheel: true,
+        }));
+        this._register(scrollbar);
+        wrapper.appendChild(scrollbar.getDomNode());
+        const signature = append(body, $('.signature'));
+        const docs = append(body, $('.docs'));
+        element.style.userSelect = 'text';
+        this.domNodes = {
+            element,
+            signature,
+            overloads,
+            docs,
+            scrollbar,
+        };
+        this.editor.addContentWidget(this);
+        this.hide();
+        this._register(this.editor.onDidChangeCursorSelection(e => {
+            if (this.visible) {
+                this.editor.layoutContentWidget(this);
+            }
+        }));
+        const updateFont = () => {
+            if (!this.domNodes) {
+                return;
+            }
+            const fontInfo = this.editor.getOption(50 );
+            this.domNodes.element.style.fontSize = `${fontInfo.fontSize}px`;
+            this.domNodes.element.style.lineHeight = `${fontInfo.lineHeight / fontInfo.fontSize}`;
+        };
+        updateFont();
+        this._register(Event.chain(this.editor.onDidChangeConfiguration.bind(this.editor), $ => $.filter(e => e.hasChanged(50 )))(updateFont));
+        this._register(this.editor.onDidLayoutChange(e => this.updateMaxHeight()));
+        this.updateMaxHeight();
+    }
+    show() {
+        if (this.visible) {
+            return;
+        }
+        if (!this.domNodes) {
+            this.createParameterHintDOMNodes();
+        }
+        this.keyVisible.set(true);
+        this.visible = true;
+        setTimeout(() => {
+            this.domNodes?.element.classList.add('visible');
+        }, 100);
+        this.editor.layoutContentWidget(this);
+    }
+    hide() {
+        this.renderDisposeables.clear();
+        if (!this.visible) {
+            return;
+        }
+        this.keyVisible.reset();
+        this.visible = false;
+        this.announcedLabel = null;
+        this.domNodes?.element.classList.remove('visible');
+        this.editor.layoutContentWidget(this);
+    }
+    getPosition() {
+        if (this.visible) {
+            return {
+                position: this.editor.getPosition(),
+                preference: [1 , 2 ]
+            };
+        }
+        return null;
+    }
+    render(hints) {
+        this.renderDisposeables.clear();
+        if (!this.domNodes) {
+            return;
+        }
+        const multiple = hints.signatures.length > 1;
+        this.domNodes.element.classList.toggle('multiple', multiple);
+        this.keyMultipleSignatures.set(multiple);
+        this.domNodes.signature.innerText = '';
+        this.domNodes.docs.innerText = '';
+        const signature = hints.signatures[hints.activeSignature];
+        if (!signature) {
+            return;
+        }
+        const code = append(this.domNodes.signature, $('.code'));
+        const fontInfo = this.editor.getOption(50 );
+        code.style.fontSize = `${fontInfo.fontSize}px`;
+        code.style.fontFamily = fontInfo.fontFamily;
+        const hasParameters = signature.parameters.length > 0;
+        const activeParameterIndex = signature.activeParameter ?? hints.activeParameter;
+        if (!hasParameters) {
+            const label = append(code, $('span'));
+            label.textContent = signature.label;
+        }
+        else {
+            this.renderParameters(code, signature, activeParameterIndex);
+        }
+        const activeParameter = signature.parameters[activeParameterIndex];
+        if (activeParameter?.documentation) {
+            const documentation = $('span.documentation');
+            if (typeof activeParameter.documentation === 'string') {
+                documentation.textContent = activeParameter.documentation;
+            }
+            else {
+                const renderedContents = this.renderMarkdownDocs(activeParameter.documentation);
+                documentation.appendChild(renderedContents.element);
+            }
+            append(this.domNodes.docs, $('p', {}, documentation));
+        }
+        if (signature.documentation === undefined) ;
+        else if (typeof signature.documentation === 'string') {
+            append(this.domNodes.docs, $('p', {}, signature.documentation));
+        }
+        else {
+            const renderedContents = this.renderMarkdownDocs(signature.documentation);
+            append(this.domNodes.docs, renderedContents.element);
+        }
+        const hasDocs = this.hasDocs(signature, activeParameter);
+        this.domNodes.signature.classList.toggle('has-docs', hasDocs);
+        this.domNodes.docs.classList.toggle('empty', !hasDocs);
+        this.domNodes.overloads.textContent =
+            String(hints.activeSignature + 1).padStart(( hints.signatures.length.toString()).length, '0') + '/' + hints.signatures.length;
+        if (activeParameter) {
+            let labelToAnnounce = '';
+            const param = signature.parameters[activeParameterIndex];
+            if (Array.isArray(param.label)) {
+                labelToAnnounce = signature.label.substring(param.label[0], param.label[1]);
+            }
+            else {
+                labelToAnnounce = param.label;
+            }
+            if (param.documentation) {
+                labelToAnnounce += typeof param.documentation === 'string' ? `, ${param.documentation}` : `, ${param.documentation.value}`;
+            }
+            if (signature.documentation) {
+                labelToAnnounce += typeof signature.documentation === 'string' ? `, ${signature.documentation}` : `, ${signature.documentation.value}`;
+            }
+            if (this.announcedLabel !== labelToAnnounce) {
+                alert(( localizeWithPath(
+                    'vs/editor/contrib/parameterHints/browser/parameterHintsWidget',
+                    'hint',
+                    "{0}, hint",
+                    labelToAnnounce
+                )));
+                this.announcedLabel = labelToAnnounce;
+            }
+        }
+        this.editor.layoutContentWidget(this);
+        this.domNodes.scrollbar.scanDomNode();
+    }
+    renderMarkdownDocs(markdown) {
+        const renderedContents = this.renderDisposeables.add(this.markdownRenderer.render(markdown, {
+            asyncRenderCallback: () => {
+                this.domNodes?.scrollbar.scanDomNode();
+            }
+        }));
+        renderedContents.element.classList.add('markdown-docs');
+        return renderedContents;
+    }
+    hasDocs(signature, activeParameter) {
+        if (activeParameter && typeof activeParameter.documentation === 'string' && assertIsDefined(activeParameter.documentation).length > 0) {
+            return true;
+        }
+        if (activeParameter && typeof activeParameter.documentation === 'object' && assertIsDefined(activeParameter.documentation).value.length > 0) {
+            return true;
+        }
+        if (signature.documentation && typeof signature.documentation === 'string' && assertIsDefined(signature.documentation).length > 0) {
+            return true;
+        }
+        if (signature.documentation && typeof signature.documentation === 'object' && assertIsDefined(signature.documentation.value).length > 0) {
+            return true;
+        }
+        return false;
+    }
+    renderParameters(parent, signature, activeParameterIndex) {
+        const [start, end] = this.getParameterLabelOffsets(signature, activeParameterIndex);
+        const beforeSpan = document.createElement('span');
+        beforeSpan.textContent = signature.label.substring(0, start);
+        const paramSpan = document.createElement('span');
+        paramSpan.textContent = signature.label.substring(start, end);
+        paramSpan.className = 'parameter active';
+        const afterSpan = document.createElement('span');
+        afterSpan.textContent = signature.label.substring(end);
+        append(parent, beforeSpan, paramSpan, afterSpan);
+    }
+    getParameterLabelOffsets(signature, paramIdx) {
+        const param = signature.parameters[paramIdx];
+        if (!param) {
+            return [0, 0];
+        }
+        else if (Array.isArray(param.label)) {
+            return param.label;
+        }
+        else if (!param.label.length) {
+            return [0, 0];
+        }
+        else {
+            const regex = ( new RegExp(`(\\W|^)${escapeRegExpCharacters(param.label)}(?=\\W|$)`, 'g'));
+            regex.test(signature.label);
+            const idx = regex.lastIndex - param.label.length;
+            return idx >= 0
+                ? [idx, regex.lastIndex]
+                : [0, 0];
+        }
+    }
+    next() {
+        this.editor.focus();
+        this.model.next();
+    }
+    previous() {
+        this.editor.focus();
+        this.model.previous();
+    }
+    getDomNode() {
+        if (!this.domNodes) {
+            this.createParameterHintDOMNodes();
+        }
+        return this.domNodes.element;
+    }
+    getId() {
+        return ParameterHintsWidget_1.ID;
+    }
+    updateMaxHeight() {
+        if (!this.domNodes) {
+            return;
+        }
+        const height = Math.max(this.editor.getLayoutInfo().height / 4, 250);
+        const maxHeight = `${height}px`;
+        this.domNodes.element.style.maxHeight = maxHeight;
+        const wrapper = this.domNodes.element.getElementsByClassName('phwrapper');
+        if (wrapper.length) {
+            wrapper[0].style.maxHeight = maxHeight;
+        }
+    }
+};
+ParameterHintsWidget = ParameterHintsWidget_1 = ( __decorate([
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IOpenerService)),
+    ( __param(4, ILanguageService))
+], ParameterHintsWidget));
+registerColor('editorHoverWidget.highlightForeground', { dark: listHighlightForeground, light: listHighlightForeground, hcDark: listHighlightForeground, hcLight: listHighlightForeground }, ( localizeWithPath(
+    'vs/editor/contrib/parameterHints/browser/parameterHintsWidget',
+    'editorHoverWidgetHighlightForeground',
+    'Foreground color of the active item in the parameter hint.'
+)));
+export { ParameterHintsWidget };