@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/{snippetsService.js → vscode/vs/workbench/contrib/snippets/browser/snippetsService.js}

@@ -1,412 +1,28 @@
-import { ISnippetsService, __decorate, __param, isStringArray, IUserDataProfileService, IFileService, ITextFileService, IExtensionResourceLoaderService, ILifecycleService, parse$1, getNodeType, Range$2 } from './polyfill.js';
-import * as monacoSuggest from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggest.js';
-import { extname as extname$1, basename as basename$1 } from 'monaco-editor/esm/vs/base/common/path.js';
-import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
-import { isEqualOrParent, extname, basename, relativePath, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { IdleValue } from 'monaco-editor/esm/vs/base/common/async.js';
-import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { SnippetParser, Placeholder, Variable, Text } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetParser.js';
-import { tail, insertInto } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { KnownSnippetVariableNames } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetVariables.js';
-import { ExtensionsRegistry } from './extensionsRegistry.js';
-import { languagesExtPoint } from './languageService.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
-import { isPatternInWord } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { compare, firstNonWhitespaceIndex, compareSubstring, isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
-import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import { DisposableStore, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { setSnippetSuggestSupport } from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggest.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { SnippetFile } from './snippetsFile.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+import { languagesExtPoint } from '../../../services/language/common/languageService.js';
+import { SnippetCompletionProvider } from './snippetCompletionProvider.js';
+import { IExtensionResourceLoaderService } from '../../../../platform/extensionResourceLoader/common/extensionResourceLoader.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { isStringArray } from 'monaco-editor/esm/vs/base/common/types.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-function setSnippetSuggestSupport (support) {
-  if (monacoSuggest.setSnippetSuggestSupport != null) {
-    monacoSuggest.setSnippetSuggestSupport(support);
-  } else {
-    console.error(
-`setSnippetSuggestSupport does not exist in monaco-editor.
-It's treeshaked out of monaco editor and needs to be reintroduced.
-If you're using webpack, you can add a loader that will polyfill it:
-\`\`\`
-{
-  test: /node_modules[\\/]monaco-editor/,
-  loader: 'vscode/webpack-loader'
-}
-\`\`\`
-`);
-  }
-}
-class SnippetBodyInsights {
-    constructor(body) {
-        this.isBogous = false;
-        this.isTrivial = false;
-        this.usesClipboardVariable = false;
-        this.usesSelectionVariable = false;
-        this.codeSnippet = body;
-        const textmateSnippet = ( (new SnippetParser())).parse(body, false);
-        const placeholders = ( (new Map()));
-        let placeholderMax = 0;
-        for (const placeholder of textmateSnippet.placeholders) {
-            placeholderMax = Math.max(placeholderMax, placeholder.index);
-        }
-        if (textmateSnippet.placeholders.length === 0) {
-            this.isTrivial = true;
-        }
-        else if (placeholderMax === 0) {
-            const last = tail(textmateSnippet.children);
-            this.isTrivial = last instanceof Placeholder && last.isFinalTabstop;
-        }
-        const stack = [...textmateSnippet.children];
-        while (stack.length > 0) {
-            const marker = stack.shift();
-            if (marker instanceof Variable) {
-                if (marker.children.length === 0 && !KnownSnippetVariableNames[marker.name]) {
-                    const index = placeholders.has(marker.name) ? placeholders.get(marker.name) : ++placeholderMax;
-                    placeholders.set(marker.name, index);
-                    const synthetic = ( (new Placeholder(index))).appendChild(( (new Text(marker.name))));
-                    textmateSnippet.replace(marker, [synthetic]);
-                    this.isBogous = true;
-                }
-                switch (marker.name) {
-                    case 'CLIPBOARD':
-                        this.usesClipboardVariable = true;
-                        break;
-                    case 'SELECTION':
-                    case 'TM_SELECTED_TEXT':
-                        this.usesSelectionVariable = true;
-                        break;
-                }
-            }
-            else {
-                stack.push(...marker.children);
-            }
-        }
-        if (this.isBogous) {
-            this.codeSnippet = textmateSnippet.toTextmateString();
-        }
-    }
-}
-class Snippet {
-    constructor(isFileTemplate, scopes, name, prefix, description, body, source, snippetSource, snippetIdentifier, extensionId) {
-        this.isFileTemplate = isFileTemplate;
-        this.scopes = scopes;
-        this.name = name;
-        this.prefix = prefix;
-        this.description = description;
-        this.body = body;
-        this.source = source;
-        this.snippetSource = snippetSource;
-        this.snippetIdentifier = snippetIdentifier;
-        this.extensionId = extensionId;
-        this.prefixLow = prefix.toLowerCase();
-        this._bodyInsights = ( (new IdleValue(() => ( (new SnippetBodyInsights(this.body))))));
-    }
-    get codeSnippet() {
-        return this._bodyInsights.value.codeSnippet;
-    }
-    get isBogous() {
-        return this._bodyInsights.value.isBogous;
-    }
-    get isTrivial() {
-        return this._bodyInsights.value.isTrivial;
-    }
-    get needsClipboard() {
-        return this._bodyInsights.value.usesClipboardVariable;
-    }
-    get usesSelection() {
-        return this._bodyInsights.value.usesSelectionVariable;
-    }
-}
-function isJsonSerializedSnippet(thing) {
-    return isObject(thing) && Boolean(thing.body);
-}
-class SnippetFile {
-    constructor(source, location, defaultScopes, _extension, _fileService, _extensionResourceLoaderService) {
-        this.source = source;
-        this.location = location;
-        this.defaultScopes = defaultScopes;
-        this._extension = _extension;
-        this._fileService = _fileService;
-        this._extensionResourceLoaderService = _extensionResourceLoaderService;
-        this.data = [];
-        this.isGlobalSnippets = extname$1(location.path) === '.code-snippets';
-        this.isUserSnippets = !this._extension;
-    }
-    select(selector, bucket) {
-        if (this.isGlobalSnippets || !this.isUserSnippets) {
-            this._scopeSelect(selector, bucket);
-        }
-        else {
-            this._filepathSelect(selector, bucket);
-        }
-    }
-    _filepathSelect(selector, bucket) {
-        if (selector + '.json' === basename$1(this.location.path)) {
-            bucket.push(...this.data);
-        }
-    }
-    _scopeSelect(selector, bucket) {
-        for (const snippet of this.data) {
-            const len = snippet.scopes.length;
-            if (len === 0) {
-                bucket.push(snippet);
-            }
-            else {
-                for (let i = 0; i < len; i++) {
-                    if (snippet.scopes[i] === selector) {
-                        bucket.push(snippet);
-                        break;
-                    }
-                }
-            }
-        }
-        const idx = selector.lastIndexOf('.');
-        if (idx >= 0) {
-            this._scopeSelect(selector.substring(0, idx), bucket);
-        }
-    }
-    async _load() {
-        if (this._extension) {
-            return this._extensionResourceLoaderService.readExtensionResource(this.location);
-        }
-        else {
-            const content = await this._fileService.readFile(this.location);
-            return (
-                 (content.value.toString())
-            );
-        }
-    }
-    load() {
-        if (!this._loadPromise) {
-            this._loadPromise = Promise.resolve(this._load()).then(content => {
-                const data = parse$1(content);
-                if (getNodeType(data) === 'object') {
-                    for (const [name, scopeOrTemplate] of Object.entries(data)) {
-                        if (isJsonSerializedSnippet(scopeOrTemplate)) {
-                            this._parseSnippet(name, scopeOrTemplate, this.data);
-                        }
-                        else {
-                            for (const [name, template] of Object.entries(scopeOrTemplate)) {
-                                this._parseSnippet(name, template, this.data);
-                            }
-                        }
-                    }
-                }
-                return this;
-            });
-        }
-        return this._loadPromise;
-    }
-    reset() {
-        this._loadPromise = undefined;
-        this.data.length = 0;
-    }
-    _parseSnippet(name, snippet, bucket) {
-        let { isFileTemplate, prefix, body, description } = snippet;
-        if (!prefix) {
-            prefix = '';
-        }
-        if (Array.isArray(body)) {
-            body = body.join('\n');
-        }
-        if (typeof body !== 'string') {
-            return;
-        }
-        if (Array.isArray(description)) {
-            description = description.join('\n');
-        }
-        let scopes;
-        if (this.defaultScopes) {
-            scopes = this.defaultScopes;
-        }
-        else if (typeof snippet.scope === 'string') {
-            scopes = ( (snippet.scope.split(',').map(s => s.trim()))).filter(Boolean);
-        }
-        else {
-            scopes = [];
-        }
-        let source;
-        if (this._extension) {
-            source = this._extension.displayName || this._extension.name;
-        }
-        else if (this.source === 2 ) {
-            source = ( (localize('source.workspaceSnippetGlobal', "Workspace Snippet")));
-        }
-        else {
-            if (this.isGlobalSnippets) {
-                source = ( (localize('source.userSnippetGlobal', "Global User Snippet")));
-            }
-            else {
-                source = ( (localize('source.userSnippet', "User Snippet")));
-            }
-        }
-        for (const _prefix of Iterable.wrap(prefix)) {
-            bucket.push(( (new Snippet(
-                Boolean(isFileTemplate),
-                scopes,
-                name,
-                _prefix,
-                description,
-                body,
-                source,
-                this.source,
-                this._extension ? `${relativePath(this._extension.extensionLocation, this.location)}/${name}` : `${basename$1(this.location.path)}/${name}`,
-                this._extension?.identifier
-            ))));
-        }
-    }
-}
-const markSnippetAsUsed = '_snippet.markAsUsed';
-CommandsRegistry.registerCommand(markSnippetAsUsed, (accessor, ...args) => {
-    const snippetsService = accessor.get(ISnippetsService);
-    const [first] = args;
-    if (first instanceof Snippet) {
-        snippetsService.updateUsageTimestamp(first);
-    }
-});
-class SnippetCompletion {
-    constructor(snippet, range) {
-        this.snippet = snippet;
-        this.label = { label: snippet.prefix, description: snippet.name };
-        this.detail = ( (localize(
-            'detail.snippet',
-            "{0} ({1})",
-            snippet.description || snippet.name,
-            snippet.source
-        )));
-        this.insertText = snippet.codeSnippet;
-        this.extensionId = snippet.extensionId;
-        this.range = range;
-        this.sortText = `${snippet.snippetSource === 3  ? 'z' : 'a'}-${snippet.prefix}`;
-        this.kind = 27 ;
-        this.insertTextRules = 4 ;
-        this.command = { id: markSnippetAsUsed, title: '', arguments: [snippet] };
-    }
-    resolve() {
-        this.documentation = ( (new MarkdownString())).appendCodeblock('', SnippetParser.asInsertText(this.snippet.codeSnippet));
-        return this;
-    }
-    static compareByLabel(a, b) {
-        return compare(a.label.label, b.label.label);
-    }
-}
-let SnippetCompletionProvider = class SnippetCompletionProvider {
-    constructor(_languageService, _snippets, _languageConfigurationService) {
-        this._languageService = _languageService;
-        this._snippets = _snippets;
-        this._languageConfigurationService = _languageConfigurationService;
-        this._debugDisplayName = 'snippetCompletions';
-    }
-    async provideCompletionItems(model, position, context) {
-        const sw = ( (new StopWatch(true)));
-        const languageId = this._getLanguageIdAtPosition(model, position);
-        const languageConfig = this._languageConfigurationService.getLanguageConfiguration(languageId);
-        const snippets = ( (new Set(await this._snippets.getSnippets(languageId))));
-        const lineContentLow = model.getLineContent(position.lineNumber).toLowerCase();
-        const wordUntil = model.getWordUntilPosition(position).word.toLowerCase();
-        const suggestions = [];
-        const columnOffset = position.column - 1;
-        const triggerCharacterLow = context.triggerCharacter?.toLowerCase() ?? '';
-        snippet: for (const snippet of snippets) {
-            if (context.triggerKind === 1  && !snippet.prefixLow.startsWith(triggerCharacterLow)) {
-                continue snippet;
-            }
-            const word = getWordAtText(1, languageConfig.getWordDefinition(), snippet.prefixLow, 0);
-            if (wordUntil && word && !isPatternInWord(wordUntil, 0, wordUntil.length, snippet.prefixLow, 0, snippet.prefixLow.length)) {
-                continue snippet;
-            }
-            const minPos = firstNonWhitespaceIndex(snippet.prefixLow) === 0
-                ? Math.max(0, model.getLineFirstNonWhitespaceColumn(position.lineNumber) - 1)
-                : 0;
-            column: for (let pos = Math.max(minPos, columnOffset - snippet.prefixLow.length); pos < lineContentLow.length; pos++) {
-                if (!isPatternInWord(lineContentLow, pos, columnOffset, snippet.prefixLow, 0, snippet.prefixLow.length)) {
-                    continue column;
-                }
-                const prefixRestLen = snippet.prefixLow.length - (columnOffset - pos);
-                const endsWithPrefixRest = compareSubstring(lineContentLow, snippet.prefixLow, columnOffset, columnOffset + prefixRestLen, columnOffset - pos);
-                const startPosition = position.with(undefined, pos + 1);
-                if (wordUntil && position.equals(startPosition)) {
-                    continue snippet;
-                }
-                let endColumn = endsWithPrefixRest === 0 ? position.column + prefixRestLen : position.column;
-                if (columnOffset < lineContentLow.length) {
-                    const autoClosingPairs = languageConfig.getAutoClosingPairs();
-                    const standardAutoClosingPairConditionals = autoClosingPairs.autoClosingPairsCloseSingleChar.get(lineContentLow[columnOffset]);
-                    if (standardAutoClosingPairConditionals?.some(p =>
-                    p.open === lineContentLow[startPosition.column - 1] &&
-                        snippet.prefix.startsWith(p.open) &&
-                        snippet.prefix[snippet.prefix.length - 1] === p.close)) {
-                        endColumn++;
-                    }
-                }
-                const replace = Range$2.fromPositions(startPosition, { lineNumber: position.lineNumber, column: endColumn });
-                const insert = replace.setEndPosition(position.lineNumber, position.column);
-                suggestions.push(( (new SnippetCompletion(snippet, { replace, insert }))));
-                snippets.delete(snippet);
-                break;
-            }
-        }
-        if (!triggerCharacterLow) {
-            const endsInWhitespace = /\s/.test(lineContentLow[position.column - 2]);
-            if (endsInWhitespace || !lineContentLow ) {
-                for (const snippet of snippets) {
-                    const insert = Range$2.fromPositions(position);
-                    const replace = lineContentLow.indexOf(snippet.prefixLow, columnOffset) === columnOffset ? insert.setEndPosition(position.lineNumber, position.column + snippet.prefixLow.length) : insert;
-                    suggestions.push(( (new SnippetCompletion(snippet, { replace, insert }))));
-                }
-            }
-        }
-        suggestions.sort(SnippetCompletion.compareByLabel);
-        for (let i = 0; i < suggestions.length; i++) {
-            const item = suggestions[i];
-            let to = i + 1;
-            for (; to < suggestions.length && item.label === suggestions[to].label; to++) {
-                suggestions[to].label.label = ( (localize(
-                    'snippetSuggest.longLabel',
-                    "{0}, {1}",
-                    suggestions[to].label.label,
-                    suggestions[to].snippet.name
-                )));
-            }
-            if (to > i + 1) {
-                suggestions[i].label.label = ( (localize(
-                    'snippetSuggest.longLabel',
-                    "{0}, {1}",
-                    suggestions[i].label.label,
-                    suggestions[i].snippet.name
-                )));
-                i = to;
-            }
-        }
-        return {
-            suggestions,
-            duration: sw.elapsed()
-        };
-    }
-    resolveCompletionItem(item) {
-        return (item instanceof SnippetCompletion) ? item.resolve() : item;
-    }
-    _getLanguageIdAtPosition(model, position) {
-        model.tokenization.tokenizeIfCheap(position.lineNumber);
-        let languageId = model.getLanguageIdAtPosition(position.lineNumber, position.column);
-        if (!this._languageService.getLanguageName(languageId)) {
-            languageId = model.getLanguageId();
-        }
-        return languageId;
-    }
-};
-SnippetCompletionProvider = ( (__decorate([
-    ( (__param(0, ILanguageService))),
-    ( (__param(1, ISnippetsService))),
-    ( (__param(2, ILanguageConfigurationService)))
-], SnippetCompletionProvider)));
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import { IUserDataProfileService } from '../../../services/userDataProfile/common/userDataProfile.js';
+import { insertInto } from 'monaco-editor/esm/vs/base/common/arrays.js';
 var snippetExt;
 ( ((function(snippetExt) {
     function toValidSnippet(extension, snippet, languageService) {
@@ -438,8 +54,8 @@ var snippetExt;
             return null;
         }
         const extensionLocation = extension.description.extensionLocation;
-        const snippetLocation = joinPath(extensionLocation, snippet.path);
-        if (!isEqualOrParent(snippetLocation, extensionLocation)) {
+        const snippetLocation = resources.joinPath(extensionLocation, snippet.path);
+        if (!resources.isEqualOrParent(snippetLocation, extensionLocation)) {
             extension.collector.error(( (localize(
                 'invalid.path.1',
                 "Expected `contributes.{0}.path` ({1}) to be included inside extension's folder ({2}). This might make the extension non-portable.",
@@ -715,7 +331,7 @@ let SnippetsService = class SnippetsService {
                         this._files.set(file.location, file);
                         if (this._environmentService.isExtensionDevelopment) {
                             file.load().then(file => {
-                                if (file.data.some(snippet => snippet.isBogous)) {
+                                if (( (file.data.some(snippet => snippet.isBogous)))) {
                                     extension.collector.warn(( (localize(
                                         'badVariableUse',
                                         "One or more snippets from the extension '{0}' very likely confuse snippet-variables and snippet-placeholders (see https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax for more details)",
@@ -798,7 +414,7 @@ let SnippetsService = class SnippetsService {
             }
         };
         bucket.add(this._textfileService.files.onDidSave(e => {
-            if (isEqualOrParent(e.model.resource, folder)) {
+            if (resources.isEqualOrParent(e.model.resource, folder)) {
                 addFolderSnippets();
             }
         }));
@@ -807,9 +423,9 @@ let SnippetsService = class SnippetsService {
         return addFolderSnippets();
     }
     _addSnippetFile(uri, source) {
-        const ext = extname(uri);
+        const ext = resources.extname(uri);
         if (source === 1  && ext === '.json') {
-            const langName = basename(uri).replace(/\.json/, '');
+            const langName = resources.basename(uri).replace(/\.json/, '');
             this._files.set(uri, ( (new SnippetFile(
                 source,
                 uri,
@@ -862,4 +478,4 @@ function getNonWhitespacePrefix(model, position) {
     }
     return '';
 }
-export { SnippetCompletion, SnippetsService, getNonWhitespacePrefix };
+export { SnippetsService, getNonWhitespacePrefix };

package/dist/vscode/vs/workbench/contrib/snippets/browser/tabCompletion.js

@@ -0,0 +1,166 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ISnippetsService } from './snippets.js';
+import { getNonWhitespacePrefix } from './snippetsService.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { registerEditorContribution, EditorCommand, registerEditorCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
+import { showSimpleSuggestions } from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggest.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { SnippetCompletion } from './snippetCompletionProvider.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { EditorState } from 'monaco-editor/esm/vs/editor/contrib/editorState/browser/editorState.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+let TabCompletionController = class TabCompletionController {
+    static get(editor) {
+        return editor.getContribution(TabCompletionController.ID);
+    }
+    constructor(_editor, _snippetService, _clipboardService, _languageFeaturesService, contextKeyService) {
+        this._editor = _editor;
+        this._snippetService = _snippetService;
+        this._clipboardService = _clipboardService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._activeSnippets = [];
+        this._hasSnippets = TabCompletionController.ContextKey.bindTo(contextKeyService);
+        this._configListener = this._editor.onDidChangeConfiguration(e => {
+            if (e.hasChanged(118 )) {
+                this._update();
+            }
+        });
+        this._update();
+    }
+    dispose() {
+        this._configListener.dispose();
+        this._selectionListener?.dispose();
+    }
+    _update() {
+        const enabled = this._editor.getOption(118 ) === 'onlySnippets';
+        if (this._enabled !== enabled) {
+            this._enabled = enabled;
+            if (!this._enabled) {
+                this._selectionListener?.dispose();
+            }
+            else {
+                this._selectionListener = this._editor.onDidChangeCursorSelection(e => this._updateSnippets());
+                if (this._editor.getModel()) {
+                    this._updateSnippets();
+                }
+            }
+        }
+    }
+    _updateSnippets() {
+        this._activeSnippets = [];
+        this._completionProvider?.dispose();
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const selection = this._editor.getSelection();
+        const model = this._editor.getModel();
+        model.tokenization.tokenizeIfCheap(selection.positionLineNumber);
+        const id = model.getLanguageIdAtPosition(selection.positionLineNumber, selection.positionColumn);
+        const snippets = this._snippetService.getSnippetsSync(id);
+        if (!snippets) {
+            this._hasSnippets.set(false);
+            return;
+        }
+        if (Range.isEmpty(selection)) {
+            const prefix = getNonWhitespacePrefix(model, selection.getPosition());
+            if (prefix) {
+                for (const snippet of snippets) {
+                    if (prefix.endsWith(snippet.prefix)) {
+                        this._activeSnippets.push(snippet);
+                    }
+                }
+            }
+        }
+        else if (!Range.spansMultipleLines(selection) && model.getValueLengthInRange(selection) <= 100) {
+            const selected = model.getValueInRange(selection);
+            if (selected) {
+                for (const snippet of snippets) {
+                    if (selected === snippet.prefix) {
+                        this._activeSnippets.push(snippet);
+                    }
+                }
+            }
+        }
+        const len = this._activeSnippets.length;
+        if (len === 0) {
+            this._hasSnippets.set(false);
+        }
+        else if (len === 1) {
+            this._hasSnippets.set(true);
+        }
+        else {
+            this._hasSnippets.set(true);
+            this._completionProvider = {
+                dispose: () => {
+                    registration.dispose();
+                },
+                provideCompletionItems: (_model, position) => {
+                    if (_model !== model || !selection.containsPosition(position)) {
+                        return;
+                    }
+                    const suggestions = ( this._activeSnippets.map(snippet => {
+                        const range = Range.fromPositions(position.delta(0, -snippet.prefix.length), position);
+                        return ( new SnippetCompletion(snippet, range));
+                    }));
+                    return { suggestions };
+                }
+            };
+            const registration = this._languageFeaturesService.completionProvider.register({ language: model.getLanguageId(), pattern: model.uri.fsPath, scheme: model.uri.scheme }, this._completionProvider);
+        }
+    }
+    async performSnippetCompletions() {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        if (this._activeSnippets.length === 1) {
+            const [snippet] = this._activeSnippets;
+            let clipboardText;
+            if (snippet.needsClipboard) {
+                const state = ( new EditorState(
+                    this._editor,
+                    1  | 4
+                ));
+                clipboardText = await this._clipboardService.readText();
+                if (!state.validate(this._editor)) {
+                    return;
+                }
+            }
+            SnippetController2.get(this._editor)?.insert(snippet.codeSnippet, {
+                overwriteBefore: snippet.prefix.length, overwriteAfter: 0,
+                clipboardText
+            });
+        }
+        else if (this._activeSnippets.length > 1) {
+            if (this._completionProvider) {
+                showSimpleSuggestions(this._editor, this._completionProvider);
+            }
+        }
+    }
+};
+TabCompletionController.ID = 'editor.tabCompletionController';
+TabCompletionController.ContextKey = ( new RawContextKey('hasSnippetCompletions', undefined));
+TabCompletionController = ( __decorate([
+    ( __param(1, ISnippetsService)),
+    ( __param(2, IClipboardService)),
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, IContextKeyService))
+], TabCompletionController));
+registerEditorContribution(TabCompletionController.ID, TabCompletionController, 0 );
+const TabCompletionCommand = EditorCommand.bindToContribution(TabCompletionController.get);
+registerEditorCommand(( new TabCompletionCommand({
+    id: 'insertSnippet',
+    precondition: TabCompletionController.ContextKey,
+    handler: x => x.performSnippetCompletions(),
+    kbOpts: {
+        weight: 100 ,
+        kbExpr: ( ContextKeyExpr.and(
+            EditorContextKeys.editorTextFocus,
+            EditorContextKeys.tabDoesNotMoveFocus,
+            ( SnippetController2.InSnippetMode.toNegated())
+        )),
+        primary: 2
+    }
+})));
+export { TabCompletionController };