yaml-language-server 1.11.1-dcdfa10.0 → 1.11.1-e8be2e1.0

package/lib/esm/languageservice/services/yamlCompletion.js

@@ -2,15 +2,6 @@
  *  Copyright (c) Red Hat, Inc. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { CompletionItem as CompletionItemBase, CompletionItemKind, CompletionList, InsertTextFormat, InsertTextMode, MarkupKind, Position, Range, TextEdit, } from 'vscode-languageserver-types';
 import { isPair, isScalar, isMap, isSeq, isNode } from 'yaml';
 import { filterInvalidCustomTags, matchOffsetToDocument } from '../utils/arrUtils';
@@ -23,7 +14,7 @@ import { setKubernetesParserOption } from '../parser/isKubernetes';
 import { asSchema } from '../parser/jsonParser07';
 import { indexOf, isInComment, isMapContainsEmptyPair } from '../utils/astUtils';
 import { isModeline } from './modelineUtil';
-import { getSchemaTypeName } from '../utils/schemaUtils';
+import { getSchemaTypeName, isAnyOfAllOfOneOfType, isPrimitiveType } from '../utils/schemaUtils';
 const localize = nls.loadMessageBundle();
 const doubleQuotesEscapeRegExp = /[\\]+"/g;
 const parentCompletionKind = CompletionItemKind.Class;
@@ -46,409 +37,438 @@ export class YamlCompletion {
         this.disableDefaultProperties = languageSettings.disableDefaultProperties;
         this.parentSkeletonSelectedFirst = languageSettings.parentSkeletonSelectedFirst;
     }
-    doComplete(document, position, isKubernetes = false, doComplete = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = CompletionList.create([], false);
-            if (!this.completionEnabled) {
-                return result;
-            }
-            const doc = this.yamlDocument.getYamlDocument(document, { customTags: this.customTags, yamlVersion: this.yamlVersion }, true);
-            const textBuffer = new TextBuffer(document);
-            if (!this.configuredIndentation) {
-                const indent = guessIndentation(textBuffer, 2, true);
-                this.indentation = indent.insertSpaces ? ' '.repeat(indent.tabSize) : '\t';
-            }
-            else {
-                this.indentation = this.configuredIndentation;
-            }
-            setKubernetesParserOption(doc.documents, isKubernetes);
-            const offset = document.offsetAt(position);
-            const text = document.getText();
-            if (text.charAt(offset - 1) === ':') {
-                return Promise.resolve(result);
-            }
-            let currentDoc = matchOffsetToDocument(offset, doc);
-            if (currentDoc === null) {
-                return Promise.resolve(result);
-            }
-            // as we modify AST for completion, we need to use copy of original document
-            currentDoc = currentDoc.clone();
-            let [node, foundByClosest] = currentDoc.getNodeFromPosition(offset, textBuffer, this.indentation.length);
-            const currentWord = this.getCurrentWord(document, offset);
-            let lineContent = textBuffer.getLineContent(position.line);
-            const lineAfterPosition = lineContent.substring(position.character);
-            const areOnlySpacesAfterPosition = /^[ ]+\n?$/.test(lineAfterPosition);
-            this.arrayPrefixIndentation = '';
-            let overwriteRange = null;
-            if (areOnlySpacesAfterPosition) {
-                overwriteRange = Range.create(position, Position.create(position.line, lineContent.length));
-                const isOnlyWhitespace = lineContent.trim().length === 0;
-                const isOnlyDash = lineContent.match(/^\s*(-)\s*$/);
-                if (node && isScalar(node) && !isOnlyWhitespace && !isOnlyDash) {
-                    // line contains part of a key with trailing spaces, adjust the overwrite range to include only the text
-                    const matches = lineContent.match(/^([\s-]*)[^:]+[ \t]+\n?$/);
-                    if (matches === null || matches === void 0 ? void 0 : matches.length) {
-                        overwriteRange = Range.create(Position.create(position.line, matches[1].length), Position.create(position.line, lineContent.length));
-                    }
-                }
-            }
-            else if (node && isScalar(node) && node.value === 'null') {
-                const nodeStartPos = document.positionAt(node.range[0]);
-                nodeStartPos.character += 1;
-                const nodeEndPos = document.positionAt(node.range[2]);
-                nodeEndPos.character += 1;
-                overwriteRange = Range.create(nodeStartPos, nodeEndPos);
-            }
-            else if (node && isScalar(node) && node.value) {
-                const start = document.positionAt(node.range[0]);
-                if (offset > 0 && start.character > 0 && text.charAt(offset - 1) === '-') {
-                    start.character -= 1;
+    async doComplete(document, position, isKubernetes = false, doComplete = true) {
+        const result = CompletionList.create([], false);
+        if (!this.completionEnabled) {
+            return result;
+        }
+        const doc = this.yamlDocument.getYamlDocument(document, { customTags: this.customTags, yamlVersion: this.yamlVersion }, true);
+        const textBuffer = new TextBuffer(document);
+        if (!this.configuredIndentation) {
+            const indent = guessIndentation(textBuffer, 2, true);
+            this.indentation = indent.insertSpaces ? ' '.repeat(indent.tabSize) : '\t';
+        }
+        else {
+            this.indentation = this.configuredIndentation;
+        }
+        setKubernetesParserOption(doc.documents, isKubernetes);
+        // set parser options
+        for (const jsonDoc of doc.documents) {
+            jsonDoc.uri = document.uri;
+        }
+        const offset = document.offsetAt(position);
+        const text = document.getText();
+        if (text.charAt(offset - 1) === ':') {
+            return Promise.resolve(result);
+        }
+        let currentDoc = matchOffsetToDocument(offset, doc);
+        if (currentDoc === null) {
+            return Promise.resolve(result);
+        }
+        // as we modify AST for completion, we need to use copy of original document
+        currentDoc = currentDoc.clone();
+        let [node, foundByClosest] = currentDoc.getNodeFromPosition(offset, textBuffer, this.indentation.length);
+        const currentWord = this.getCurrentWord(document, offset);
+        let lineContent = textBuffer.getLineContent(position.line);
+        const lineAfterPosition = lineContent.substring(position.character);
+        const areOnlySpacesAfterPosition = /^[ ]+\n?$/.test(lineAfterPosition);
+        this.arrayPrefixIndentation = '';
+        let overwriteRange = null;
+        if (areOnlySpacesAfterPosition) {
+            overwriteRange = Range.create(position, Position.create(position.line, lineContent.length));
+            const isOnlyWhitespace = lineContent.trim().length === 0;
+            const isOnlyDash = lineContent.match(/^\s*(-)\s*$/);
+            if (node && isScalar(node) && !isOnlyWhitespace && !isOnlyDash) {
+                // line contains part of a key with trailing spaces, adjust the overwrite range to include only the text
+                const matches = lineContent.match(/^([\s-]*)[^:]+[ \t]+\n?$/);
+                if (matches?.length) {
+                    overwriteRange = Range.create(Position.create(position.line, matches[1].length), Position.create(position.line, lineContent.length));
                 }
-                overwriteRange = Range.create(start, document.positionAt(node.range[1]));
             }
-            else if (node && isScalar(node) && node.value === null && currentWord === '-') {
-                overwriteRange = Range.create(position, position);
-                this.arrayPrefixIndentation = ' ';
+        }
+        else if (node && isScalar(node) && node.value === 'null') {
+            const nodeStartPos = document.positionAt(node.range[0]);
+            nodeStartPos.character += 1;
+            const nodeEndPos = document.positionAt(node.range[2]);
+            nodeEndPos.character += 1;
+            overwriteRange = Range.create(nodeStartPos, nodeEndPos);
+        }
+        else if (node && isScalar(node) && node.value) {
+            const start = document.positionAt(node.range[0]);
+            if (offset > 0 && start.character > 0 && text.charAt(offset - 1) === '-') {
+                start.character -= 1;
             }
-            else {
-                let overwriteStart = document.offsetAt(position) - currentWord.length;
-                if (overwriteStart > 0 && text[overwriteStart - 1] === '"') {
-                    overwriteStart--;
-                }
-                overwriteRange = Range.create(document.positionAt(overwriteStart), position);
+            overwriteRange = Range.create(start, document.positionAt(node.range[1]));
+        }
+        else if (node && isScalar(node) && node.value === null && currentWord === '-') {
+            overwriteRange = Range.create(position, position);
+            this.arrayPrefixIndentation = ' ';
+        }
+        else {
+            let overwriteStart = document.offsetAt(position) - currentWord.length;
+            if (overwriteStart > 0 && text[overwriteStart - 1] === '"') {
+                overwriteStart--;
             }
-            const proposed = {};
-            const existingProposeItem = '__';
-            const collector = {
-                add: (completionItem) => {
-                    const addSuggestionForParent = function (completionItem) {
-                        var _a;
-                        const existsInYaml = ((_a = proposed[completionItem.label]) === null || _a === void 0 ? void 0 : _a.label) === existingProposeItem;
-                        //don't put to parent suggestion if already in yaml
-                        if (existsInYaml) {
-                            return;
-                        }
-                        const schema = completionItem.parent.schema;
-                        const schemaType = getSchemaTypeName(schema);
-                        const schemaDescription = schema.markdownDescription || schema.description;
-                        let parentCompletion = result.items.find((item) => { var _a; return ((_a = item.parent) === null || _a === void 0 ? void 0 : _a.schema) === schema && item.kind === parentCompletionKind; });
-                        if (parentCompletion && parentCompletion.parent.insertTexts.includes(completionItem.insertText)) {
-                            // already exists in the parent
-                            return;
-                        }
-                        else if (!parentCompletion) {
-                            // create a new parent
-                            parentCompletion = Object.assign(Object.assign({}, completionItem), { label: schemaType, documentation: schemaDescription, sortText: '_' + schemaType, kind: parentCompletionKind });
-                            parentCompletion.parent.insertTexts = [completionItem.insertText];
-                            result.items.push(parentCompletion);
-                        }
-                        else {
-                            // add to the existing parent
-                            parentCompletion.parent.insertTexts.push(completionItem.insertText);
-                        }
-                    };
-                    const isForParentCompletion = !!completionItem.parent;
-                    let label = completionItem.label;
-                    if (!label) {
-                        // we receive not valid CompletionItem as `label` is mandatory field, so just ignore it
-                        console.warn(`Ignoring CompletionItem without label: ${JSON.stringify(completionItem)}`);
+            overwriteRange = Range.create(document.positionAt(overwriteStart), position);
+        }
+        const proposed = {};
+        const existingProposeItem = '__';
+        const collector = {
+            add: (completionItem, oneOfSchema) => {
+                const addSuggestionForParent = function (completionItem) {
+                    const existsInYaml = proposed[completionItem.label]?.label === existingProposeItem;
+                    //don't put to parent suggestion if already in yaml
+                    if (existsInYaml) {
                         return;
                     }
-                    if (!isString(label)) {
-                        label = String(label);
-                    }
-                    label = label.replace(/[\n]/g, '↵');
-                    if (label.length > 60) {
-                        const shortendedLabel = label.substr(0, 57).trim() + '...';
-                        if (!proposed[shortendedLabel]) {
-                            label = shortendedLabel;
-                        }
+                    const schema = completionItem.parent.schema;
+                    const schemaType = getSchemaTypeName(schema);
+                    const schemaDescription = schema.markdownDescription || schema.description;
+                    let parentCompletion = result.items.find((item) => item.parent?.schema === schema && item.kind === parentCompletionKind);
+                    if (parentCompletion && parentCompletion.parent.insertTexts.includes(completionItem.insertText)) {
+                        // already exists in the parent
+                        return;
                     }
-                    // trim $1 from end of completion
-                    if (completionItem.insertText.endsWith('$1') && !isForParentCompletion) {
-                        completionItem.insertText = completionItem.insertText.substr(0, completionItem.insertText.length - 2);
+                    else if (!parentCompletion) {
+                        // create a new parent
+                        parentCompletion = {
+                            ...completionItem,
+                            label: schemaType,
+                            documentation: schemaDescription,
+                            sortText: '_' + schemaType,
+                            kind: parentCompletionKind,
+                        };
+                        parentCompletion.label = parentCompletion.label || completionItem.label;
+                        parentCompletion.parent.insertTexts = [completionItem.insertText];
+                        result.items.push(parentCompletion);
                     }
-                    if (overwriteRange && overwriteRange.start.line === overwriteRange.end.line) {
-                        completionItem.textEdit = TextEdit.replace(overwriteRange, completionItem.insertText);
+                    else {
+                        // add to the existing parent
+                        parentCompletion.parent.insertTexts.push(completionItem.insertText);
                     }
-                    completionItem.label = label;
-                    if (isForParentCompletion) {
-                        addSuggestionForParent(completionItem);
-                        return;
+                };
+                const isForParentCompletion = !!completionItem.parent;
+                let label = completionItem.label;
+                if (!label) {
+                    // we receive not valid CompletionItem as `label` is mandatory field, so just ignore it
+                    console.warn(`Ignoring CompletionItem without label: ${JSON.stringify(completionItem)}`);
+                    return;
+                }
+                if (!isString(label)) {
+                    label = String(label);
+                }
+                label = label.replace(/[\n]/g, '↵');
+                if (label.length > 60) {
+                    const shortendedLabel = label.substr(0, 57).trim() + '...';
+                    if (!proposed[shortendedLabel]) {
+                        label = shortendedLabel;
                     }
-                    if (this.arrayPrefixIndentation) {
-                        this.updateCompletionText(completionItem, this.arrayPrefixIndentation + completionItem.insertText);
+                }
+                // trim $1 from end of completion
+                if (completionItem.insertText.endsWith('$1') && !isForParentCompletion) {
+                    completionItem.insertText = completionItem.insertText.substr(0, completionItem.insertText.length - 2);
+                }
+                if (overwriteRange && overwriteRange.start.line === overwriteRange.end.line) {
+                    completionItem.textEdit = TextEdit.replace(overwriteRange, completionItem.insertText);
+                }
+                completionItem.label = label;
+                if (isForParentCompletion) {
+                    addSuggestionForParent(completionItem);
+                    return;
+                }
+                if (this.arrayPrefixIndentation) {
+                    this.updateCompletionText(completionItem, this.arrayPrefixIndentation + completionItem.insertText);
+                }
+                const existing = proposed[label];
+                const isInsertTextDifferent = existing?.label !== existingProposeItem && existing?.insertText !== completionItem.insertText;
+                if (!existing) {
+                    proposed[label] = completionItem;
+                    result.items.push(completionItem);
+                }
+                else if (isInsertTextDifferent) {
+                    // try to merge simple insert values
+                    const mergedText = this.mergeSimpleInsertTexts(label, existing.insertText, completionItem.insertText, oneOfSchema);
+                    if (mergedText) {
+                        this.updateCompletionText(existing, mergedText);
                     }
-                    const existing = proposed[label];
-                    const isInsertTextDifferent = (existing === null || existing === void 0 ? void 0 : existing.label) !== existingProposeItem && (existing === null || existing === void 0 ? void 0 : existing.insertText) !== completionItem.insertText;
-                    if (!existing) {
+                    else {
+                        // add to result when it wasn't able to merge (even if the item is already there but with a different value)
                         proposed[label] = completionItem;
                         result.items.push(completionItem);
                     }
-                    else if (isInsertTextDifferent) {
-                        // try to merge simple insert values
-                        const mergedText = this.mergeSimpleInsertTexts(label, existing.insertText, completionItem.insertText);
-                        if (mergedText) {
-                            this.updateCompletionText(existing, mergedText);
-                        }
-                        else {
-                            // add to result when it wasn't able to merge (even if the item is already there but with a different value)
-                            proposed[label] = completionItem;
-                            result.items.push(completionItem);
-                        }
-                    }
-                    if (existing && !existing.documentation && completionItem.documentation) {
-                        existing.documentation = completionItem.documentation;
-                    }
-                },
-                error: (message) => {
-                    this.telemetry.sendError('yaml.completion.error', { error: convertErrorToTelemetryMsg(message) });
-                },
-                log: (message) => {
-                    console.log(message);
-                },
-                getNumberOfProposals: () => {
-                    return result.items.length;
-                },
-            };
-            if (this.customTags.length > 0) {
-                this.getCustomTagValueCompletions(collector);
-            }
-            if (lineContent.endsWith('\n')) {
-                lineContent = lineContent.substr(0, lineContent.length - 1);
+                }
+                if (existing && !existing.documentation && completionItem.documentation) {
+                    existing.documentation = completionItem.documentation;
+                }
+            },
+            error: (message) => {
+                this.telemetry.sendError('yaml.completion.error', { error: convertErrorToTelemetryMsg(message) });
+            },
+            log: (message) => {
+                console.log(message);
+            },
+            getNumberOfProposals: () => {
+                return result.items.length;
+            },
+            result,
+        };
+        if (this.customTags.length > 0) {
+            this.getCustomTagValueCompletions(collector);
+        }
+        if (lineContent.endsWith('\n')) {
+            lineContent = lineContent.substr(0, lineContent.length - 1);
+        }
+        try {
+            const schema = await this.schemaService.getSchemaForResource(document.uri, currentDoc);
+            if (!schema || schema.errors.length) {
+                if (position.line === 0 && position.character === 0 && !isModeline(lineContent)) {
+                    const inlineSchemaCompletion = {
+                        kind: CompletionItemKind.Text,
+                        label: 'Inline schema',
+                        insertText: '# yaml-language-server: $schema=',
+                        insertTextFormat: InsertTextFormat.PlainText,
+                    };
+                    result.items.push(inlineSchemaCompletion);
+                }
             }
-            try {
-                const schema = yield this.schemaService.getSchemaForResource(document.uri, currentDoc);
-                if (!schema || schema.errors.length) {
-                    if (position.line === 0 && position.character === 0 && !isModeline(lineContent)) {
-                        const inlineSchemaCompletion = {
-                            kind: CompletionItemKind.Text,
-                            label: 'Inline schema',
-                            insertText: '# yaml-language-server: $schema=',
+            if (isModeline(lineContent) || isInComment(doc.tokens, offset)) {
+                const schemaIndex = lineContent.indexOf('$schema=');
+                if (schemaIndex !== -1 && schemaIndex + '$schema='.length <= position.character) {
+                    this.schemaService.getAllSchemas().forEach((schema) => {
+                        const schemaIdCompletion = {
+                            kind: CompletionItemKind.Constant,
+                            label: schema.name ?? schema.uri,
+                            detail: schema.description,
+                            insertText: schema.uri,
                             insertTextFormat: InsertTextFormat.PlainText,
+                            insertTextMode: InsertTextMode.asIs,
                         };
-                        result.items.push(inlineSchemaCompletion);
-                    }
+                        result.items.push(schemaIdCompletion);
+                    });
                 }
-                if (isModeline(lineContent) || isInComment(doc.tokens, offset)) {
-                    const schemaIndex = lineContent.indexOf('$schema=');
-                    if (schemaIndex !== -1 && schemaIndex + '$schema='.length <= position.character) {
-                        this.schemaService.getAllSchemas().forEach((schema) => {
-                            var _a;
-                            const schemaIdCompletion = {
-                                kind: CompletionItemKind.Constant,
-                                label: (_a = schema.name) !== null && _a !== void 0 ? _a : schema.uri,
-                                detail: schema.description,
-                                insertText: schema.uri,
-                                insertTextFormat: InsertTextFormat.PlainText,
-                                insertTextMode: InsertTextMode.asIs,
-                            };
-                            result.items.push(schemaIdCompletion);
-                        });
-                    }
-                    return result;
+                return result;
+            }
+            if (!schema || schema.errors.length) {
+                return result;
+            }
+            let currentProperty = null;
+            if (!node) {
+                if (!currentDoc.internalDocument.contents || isScalar(currentDoc.internalDocument.contents)) {
+                    const map = currentDoc.internalDocument.createNode({});
+                    map.range = [offset, offset + 1, offset + 1];
+                    currentDoc.internalDocument.contents = map;
+                    // eslint-disable-next-line no-self-assign
+                    currentDoc.internalDocument = currentDoc.internalDocument;
+                    node = map;
                 }
-                if (!schema || schema.errors.length) {
-                    return result;
+                else {
+                    node = currentDoc.findClosestNode(offset, textBuffer);
+                    foundByClosest = true;
                 }
-                let currentProperty = null;
-                if (!node) {
-                    if (!currentDoc.internalDocument.contents || isScalar(currentDoc.internalDocument.contents)) {
-                        const map = currentDoc.internalDocument.createNode({});
-                        map.range = [offset, offset + 1, offset + 1];
-                        currentDoc.internalDocument.contents = map;
-                        // eslint-disable-next-line no-self-assign
-                        currentDoc.internalDocument = currentDoc.internalDocument;
-                        node = map;
-                    }
-                    else {
-                        node = currentDoc.findClosestNode(offset, textBuffer);
-                        foundByClosest = true;
-                    }
+            }
+            const originalNode = node;
+            if (node) {
+                if (lineContent.length === 0) {
+                    node = currentDoc.internalDocument.contents;
                 }
-                const originalNode = node;
-                if (node) {
-                    if (lineContent.length === 0) {
-                        node = currentDoc.internalDocument.contents;
-                    }
-                    else {
-                        const parent = currentDoc.getParent(node);
-                        if (parent) {
-                            if (isScalar(node)) {
-                                if (node.value) {
-                                    if (isPair(parent)) {
-                                        if (parent.value === node) {
-                                            if (lineContent.trim().length > 0 && lineContent.indexOf(':') < 0) {
-                                                const map = this.createTempObjNode(currentWord, node, currentDoc);
-                                                const parentParent = currentDoc.getParent(parent);
-                                                if (isSeq(currentDoc.internalDocument.contents)) {
-                                                    const index = indexOf(currentDoc.internalDocument.contents, parent);
-                                                    if (typeof index === 'number') {
-                                                        currentDoc.internalDocument.set(index, map);
-                                                        // eslint-disable-next-line no-self-assign
-                                                        currentDoc.internalDocument = currentDoc.internalDocument;
-                                                    }
-                                                }
-                                                else if (parentParent && (isMap(parentParent) || isSeq(parentParent))) {
-                                                    parentParent.set(parent.key, map);
-                                                    // eslint-disable-next-line no-self-assign
-                                                    currentDoc.internalDocument = currentDoc.internalDocument;
-                                                }
-                                                else {
-                                                    currentDoc.internalDocument.set(parent.key, map);
+                else {
+                    const parent = currentDoc.getParent(node);
+                    if (parent) {
+                        if (isScalar(node)) {
+                            if (node.value) {
+                                if (isPair(parent)) {
+                                    if (parent.value === node) {
+                                        if (lineContent.trim().length > 0 && lineContent.indexOf(':') < 0) {
+                                            const map = this.createTempObjNode(currentWord, node, currentDoc);
+                                            const parentParent = currentDoc.getParent(parent);
+                                            if (isSeq(currentDoc.internalDocument.contents)) {
+                                                const index = indexOf(currentDoc.internalDocument.contents, parent);
+                                                if (typeof index === 'number') {
+                                                    currentDoc.internalDocument.set(index, map);
                                                     // eslint-disable-next-line no-self-assign
                                                     currentDoc.internalDocument = currentDoc.internalDocument;
                                                 }
-                                                currentProperty = map.items[0];
-                                                node = map;
                                             }
-                                            else if (lineContent.trim().length === 0) {
-                                                const parentParent = currentDoc.getParent(parent);
-                                                if (parentParent) {
-                                                    node = parentParent;
-                                                }
+                                            else if (parentParent && (isMap(parentParent) || isSeq(parentParent))) {
+                                                parentParent.set(parent.key, map);
+                                                // eslint-disable-next-line no-self-assign
+                                                currentDoc.internalDocument = currentDoc.internalDocument;
+                                            }
+                                            else {
+                                                currentDoc.internalDocument.set(parent.key, map);
+                                                // eslint-disable-next-line no-self-assign
+                                                currentDoc.internalDocument = currentDoc.internalDocument;
                                             }
+                                            currentProperty = map.items[0];
+                                            node = map;
                                         }
-                                        else if (parent.key === node) {
+                                        else if (lineContent.trim().length === 0) {
                                             const parentParent = currentDoc.getParent(parent);
-                                            currentProperty = parent;
                                             if (parentParent) {
                                                 node = parentParent;
                                             }
                                         }
                                     }
-                                    else if (isSeq(parent)) {
-                                        if (lineContent.trim().length > 0) {
-                                            const map = this.createTempObjNode(currentWord, node, currentDoc);
-                                            parent.delete(node);
-                                            parent.add(map);
-                                            // eslint-disable-next-line no-self-assign
-                                            currentDoc.internalDocument = currentDoc.internalDocument;
-                                            node = map;
-                                        }
-                                        else {
-                                            node = parent;
+                                    else if (parent.key === node) {
+                                        const parentParent = currentDoc.getParent(parent);
+                                        currentProperty = parent;
+                                        if (parentParent) {
+                                            node = parentParent;
                                         }
                                     }
                                 }
-                                else if (node.value === null) {
-                                    if (isPair(parent)) {
-                                        if (parent.key === node) {
-                                            node = parent;
-                                        }
-                                        else {
-                                            if (isNode(parent.key) && parent.key.range) {
-                                                const parentParent = currentDoc.getParent(parent);
-                                                if (foundByClosest && parentParent && isMap(parentParent) && isMapContainsEmptyPair(parentParent)) {
-                                                    node = parentParent;
-                                                }
-                                                else {
-                                                    const parentPosition = document.positionAt(parent.key.range[0]);
-                                                    //if cursor has bigger indentation that parent key, then we need to complete new empty object
-                                                    if (position.character > parentPosition.character && position.line !== parentPosition.line) {
-                                                        const map = this.createTempObjNode(currentWord, node, currentDoc);
-                                                        if (parentParent && (isMap(parentParent) || isSeq(parentParent))) {
-                                                            parentParent.set(parent.key, map);
-                                                            // eslint-disable-next-line no-self-assign
-                                                            currentDoc.internalDocument = currentDoc.internalDocument;
-                                                        }
-                                                        else {
-                                                            currentDoc.internalDocument.set(parent.key, map);
-                                                            // eslint-disable-next-line no-self-assign
-                                                            currentDoc.internalDocument = currentDoc.internalDocument;
-                                                        }
-                                                        currentProperty = map.items[0];
-                                                        node = map;
+                                else if (isSeq(parent)) {
+                                    if (lineContent.trim().length > 0) {
+                                        const map = this.createTempObjNode(currentWord, node, currentDoc);
+                                        parent.delete(node);
+                                        parent.add(map);
+                                        // eslint-disable-next-line no-self-assign
+                                        currentDoc.internalDocument = currentDoc.internalDocument;
+                                        node = map;
+                                    }
+                                    else {
+                                        node = parent;
+                                    }
+                                }
+                            }
+                            else if (node.value === null) {
+                                if (isPair(parent)) {
+                                    if (parent.key === node) {
+                                        node = parent;
+                                    }
+                                    else {
+                                        if (isNode(parent.key) && parent.key.range) {
+                                            const parentParent = currentDoc.getParent(parent);
+                                            if (foundByClosest && parentParent && isMap(parentParent) && isMapContainsEmptyPair(parentParent)) {
+                                                node = parentParent;
+                                            }
+                                            else {
+                                                const parentPosition = document.positionAt(parent.key.range[0]);
+                                                //if cursor has bigger indentation that parent key, then we need to complete new empty object
+                                                if (position.character > parentPosition.character && position.line !== parentPosition.line) {
+                                                    const map = this.createTempObjNode(currentWord, node, currentDoc);
+                                                    if (parentParent && (isMap(parentParent) || isSeq(parentParent))) {
+                                                        parentParent.set(parent.key, map);
+                                                        // eslint-disable-next-line no-self-assign
+                                                        currentDoc.internalDocument = currentDoc.internalDocument;
                                                     }
-                                                    else if (parentPosition.character === position.character) {
-                                                        if (parentParent) {
-                                                            node = parentParent;
-                                                        }
+                                                    else {
+                                                        currentDoc.internalDocument.set(parent.key, map);
+                                                        // eslint-disable-next-line no-self-assign
+                                                        currentDoc.internalDocument = currentDoc.internalDocument;
+                                                    }
+                                                    currentProperty = map.items[0];
+                                                    node = map;
+                                                }
+                                                else if (parentPosition.character === position.character) {
+                                                    if (parentParent) {
+                                                        node = parentParent;
                                                     }
                                                 }
                                             }
                                         }
                                     }
-                                    else if (isSeq(parent)) {
-                                        if (lineContent.charAt(position.character - 1) !== '-') {
-                                            const map = this.createTempObjNode(currentWord, node, currentDoc);
-                                            parent.delete(node);
-                                            parent.add(map);
-                                            // eslint-disable-next-line no-self-assign
-                                            currentDoc.internalDocument = currentDoc.internalDocument;
-                                            node = map;
-                                        }
-                                        else if (lineContent.charAt(position.character - 1) === '-') {
-                                            const map = this.createTempObjNode('', node, currentDoc);
-                                            parent.delete(node);
-                                            parent.add(map);
-                                            // eslint-disable-next-line no-self-assign
-                                            currentDoc.internalDocument = currentDoc.internalDocument;
-                                            node = map;
-                                        }
-                                        else {
-                                            node = parent;
-                                        }
-                                    }
                                 }
-                            }
-                            else if (isMap(node)) {
-                                if (!foundByClosest && lineContent.trim().length === 0 && isSeq(parent)) {
-                                    const nextLine = textBuffer.getLineContent(position.line + 1);
-                                    if (textBuffer.getLineCount() === position.line + 1 || nextLine.trim().length === 0) {
+                                else if (isSeq(parent)) {
+                                    if (lineContent.charAt(position.character - 1) !== '-') {
+                                        const map = this.createTempObjNode(currentWord, node, currentDoc);
+                                        parent.delete(node);
+                                        parent.add(map);
+                                        // eslint-disable-next-line no-self-assign
+                                        currentDoc.internalDocument = currentDoc.internalDocument;
+                                        node = map;
+                                    }
+                                    else if (lineContent.charAt(position.character - 1) === '-') {
+                                        const map = this.createTempObjNode('', node, currentDoc);
+                                        parent.delete(node);
+                                        parent.add(map);
+                                        // eslint-disable-next-line no-self-assign
+                                        currentDoc.internalDocument = currentDoc.internalDocument;
+                                        node = map;
+                                    }
+                                    else {
                                         node = parent;
                                     }
                                 }
                             }
                         }
-                        else if (isScalar(node)) {
+                        else if (isMap(node)) {
+                            if (!foundByClosest && lineContent.trim().length === 0 && isSeq(parent)) {
+                                const nextLine = textBuffer.getLineContent(position.line + 1);
+                                if (textBuffer.getLineCount() === position.line + 1 || nextLine.trim().length === 0) {
+                                    node = parent;
+                                }
+                            }
+                        }
+                    }
+                    else if (isScalar(node)) {
+                        const map = this.createTempObjNode(currentWord, node, currentDoc);
+                        currentDoc.internalDocument.contents = map;
+                        // eslint-disable-next-line no-self-assign
+                        currentDoc.internalDocument = currentDoc.internalDocument;
+                        currentProperty = map.items[0];
+                        node = map;
+                    }
+                    else if (isMap(node)) {
+                        for (const pair of node.items) {
+                            if (isNode(pair.value) && pair.value.range && pair.value.range[0] === offset + 1) {
+                                node = pair.value;
+                            }
+                        }
+                    }
+                    else if (isSeq(node)) {
+                        if (lineContent.charAt(position.character - 1) !== '-') {
                             const map = this.createTempObjNode(currentWord, node, currentDoc);
-                            currentDoc.internalDocument.contents = map;
+                            map.items = [];
                             // eslint-disable-next-line no-self-assign
                             currentDoc.internalDocument = currentDoc.internalDocument;
-                            currentProperty = map.items[0];
-                            node = map;
-                        }
-                        else if (isMap(node)) {
                             for (const pair of node.items) {
-                                if (isNode(pair.value) && pair.value.range && pair.value.range[0] === offset + 1) {
-                                    node = pair.value;
+                                if (isMap(pair)) {
+                                    pair.items.forEach((value) => {
+                                        map.items.push(value);
+                                    });
                                 }
                             }
+                            node = map;
                         }
                     }
                 }
-                // completion for object keys
-                if (node && isMap(node)) {
-                    // don't suggest properties that are already present
-                    const properties = node.items;
-                    for (const p of properties) {
-                        if (!currentProperty || currentProperty !== p) {
-                            if (isScalar(p.key)) {
-                                proposed[p.key.value + ''] = CompletionItemBase.create(existingProposeItem);
-                            }
+            }
+            // completion for object keys
+            if (node && isMap(node)) {
+                // don't suggest properties that are already present
+                const properties = node.items;
+                for (const p of properties) {
+                    if (!currentProperty || currentProperty !== p) {
+                        if (isScalar(p.key)) {
+                            proposed[p.key.value + ''] = CompletionItemBase.create(existingProposeItem);
                         }
                     }
-                    this.addPropertyCompletions(schema, currentDoc, node, originalNode, '', collector, textBuffer, overwriteRange, doComplete);
-                    if (!schema && currentWord.length > 0 && text.charAt(offset - currentWord.length - 1) !== '"') {
-                        collector.add({
-                            kind: CompletionItemKind.Property,
-                            label: currentWord,
-                            insertText: this.getInsertTextForProperty(currentWord, null, ''),
-                            insertTextFormat: InsertTextFormat.Snippet,
-                        });
-                    }
                 }
-                // proposals for values
-                const types = {};
-                this.getValueCompletions(schema, currentDoc, node, offset, document, collector, types, doComplete);
-            }
-            catch (err) {
-                this.telemetry.sendError('yaml.completion.error', { error: convertErrorToTelemetryMsg(err) });
+                this.addPropertyCompletions(schema, currentDoc, node, originalNode, '', collector, textBuffer, overwriteRange, doComplete);
+                if (!schema && currentWord.length > 0 && text.charAt(offset - currentWord.length - 1) !== '"') {
+                    collector.add({
+                        kind: CompletionItemKind.Property,
+                        label: currentWord,
+                        insertText: this.getInsertTextForProperty(currentWord, null, ''),
+                        insertTextFormat: InsertTextFormat.Snippet,
+                    });
+                }
             }
-            this.finalizeParentCompletion(result);
-            return result;
-        });
+            // proposals for values
+            const types = {};
+            this.getValueCompletions(schema, currentDoc, node, offset, document, collector, types, doComplete);
+        }
+        catch (err) {
+            this.telemetry.sendError('yaml.completion.error', { error: convertErrorToTelemetryMsg(err) });
+        }
+        this.finalizeParentCompletion(result);
+        const uniqueItems = result.items.filter((arr, index, self) => index ===
+            self.findIndex((item) => item.label === arr.label && item.insertText === arr.insertText && item.kind === arr.kind));
+        if (uniqueItems?.length > 0) {
+            result.items = uniqueItems;
+        }
+        return result;
     }
     updateCompletionText(completionItem, text) {
         completionItem.insertText = text;
@@ -456,11 +476,22 @@ export class YamlCompletion {
             completionItem.textEdit.newText = text;
         }
     }
-    mergeSimpleInsertTexts(label, existingText, addingText) {
+    mergeSimpleInsertTexts(label, existingText, addingText, oneOfSchema) {
         const containsNewLineAfterColon = (value) => {
             return value.includes('\n');
         };
+        const startWithNewLine = (value) => {
+            return value.startsWith('\n');
+        };
+        const isNullObject = (value) => {
+            const index = value.indexOf('\n');
+            return index > 0 && value.substring(index, value.length).trim().length === 0;
+        };
         if (containsNewLineAfterColon(existingText) || containsNewLineAfterColon(addingText)) {
+            //if the exisiting object null one then replace with the non-null object
+            if (oneOfSchema && isNullObject(existingText) && !isNullObject(addingText) && !startWithNewLine(addingText)) {
+                return addingText;
+            }
             return undefined;
         }
         const existingValues = this.getValuesFromInsertText(existingText);
@@ -541,7 +572,6 @@ export class YamlCompletion {
         return map;
     }
     addPropertyCompletions(schema, doc, node, originalNode, separatorAfter, collector, textBuffer, overwriteRange, doComplete) {
-        var _a, _b;
         const matchingSchemas = doc.getMatchingSchemas(schema.schema, -1, null, doComplete);
         const existingKey = textBuffer.getText(overwriteRange);
         const lineContent = textBuffer.getLineContent(overwriteRange.start.line);
@@ -550,8 +580,19 @@ export class YamlCompletion {
         const isInArray = lineContent.trimLeft().indexOf('-') === 0;
         const nodeParent = doc.getParent(node);
         const matchOriginal = matchingSchemas.find((it) => it.node.internalNode === originalNode && it.schema.properties);
+        const oneOfSchema = matchingSchemas.filter((schema) => schema.schema.oneOf).map((oneOfSchema) => oneOfSchema.schema.oneOf)[0];
+        let didOneOfSchemaMatches = false;
+        if (oneOfSchema?.length < matchingSchemas.length) {
+            oneOfSchema?.forEach((property, index) => {
+                if (!matchingSchemas[index]?.schema.oneOf && matchingSchemas[index]?.schema.properties === property.properties) {
+                    didOneOfSchemaMatches = true;
+                }
+            });
+        }
         for (const schema of matchingSchemas) {
-            if (((schema.node.internalNode === node && !matchOriginal) || (schema.node.internalNode === originalNode && !hasColon)) &&
+            if (((schema.node.internalNode === node && !matchOriginal) ||
+                (schema.node.internalNode === originalNode && !hasColon) ||
+                (schema.node.parent?.internalNode === originalNode && !hasColon)) &&
                 !schema.inverted) {
                 this.collectDefaultSnippets(schema.schema, separatorAfter, collector, {
                     newLineFirst: false,
@@ -594,18 +635,10 @@ export class YamlCompletion {
                                             textBuffer.getPosition(it.key.range[2]).line === overwriteRange.end.line - 1)) &&
                                         pair) {
                                         if (Array.isArray(propertySchema.items)) {
-                                            this.addSchemaValueCompletions(propertySchema.items[0], separatorAfter, collector, {});
+                                            this.addSchemaValueCompletions(propertySchema.items[0], separatorAfter, collector, {}, 'property');
                                         }
                                         else if (typeof propertySchema.items === 'object' && propertySchema.items.type === 'object') {
-                                            const insertText = `- ${this.getInsertTextForObject(propertySchema.items, separatorAfter, '  ').insertText.trimLeft()}`;
-                                            const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${propertySchema.description ? ' (' + propertySchema.description + ')' : ''}`, insertText);
-                                            collector.add({
-                                                kind: this.getSuggestionKind(propertySchema.items.type),
-                                                label: '- (array item)',
-                                                documentation,
-                                                insertText,
-                                                insertTextFormat: InsertTextFormat.Snippet,
-                                            });
+                                            this.addArrayItemValueCompletion(propertySchema.items, separatorAfter, collector);
                                         }
                                     }
                                     let insertText = key;
@@ -614,7 +647,7 @@ export class YamlCompletion {
                                     }
                                     const isNodeNull = (isScalar(originalNode) && originalNode.value === null) ||
                                         (isMap(originalNode) && originalNode.items.length === 0);
-                                    const existsParentCompletion = ((_a = schema.schema.required) === null || _a === void 0 ? void 0 : _a.length) > 0;
+                                    const existsParentCompletion = schema.schema.required?.length > 0;
                                     if (!this.parentSkeletonSelectedFirst || !isNodeNull || !existsParentCompletion) {
                                         collector.add({
                                             kind: CompletionItemKind.Property,
@@ -622,10 +655,10 @@ export class YamlCompletion {
                                             insertText,
                                             insertTextFormat: InsertTextFormat.Snippet,
                                             documentation: this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || '',
-                                        });
+                                        }, didOneOfSchemaMatches);
                                     }
                                     // if the prop is required add it also to parent suggestion
-                                    if ((_b = schema.schema.required) === null || _b === void 0 ? void 0 : _b.includes(key)) {
+                                    if (schema.schema.required?.includes(key)) {
                                         collector.add({
                                             label: key,
                                             insertText: this.getInsertTextForProperty(key, propertySchema, separatorAfter, identCompensation + this.indentation),
@@ -647,8 +680,8 @@ export class YamlCompletion {
                 //  test:
                 //    - item1
                 // it will treated as a property key since `:` has been appended
-                if (nodeParent && isSeq(nodeParent) && schema.schema.type !== 'object') {
-                    this.addSchemaValueCompletions(schema.schema, separatorAfter, collector, {}, Array.isArray(nodeParent.items));
+                if (nodeParent && isSeq(nodeParent) && isPrimitiveType(schema.schema)) {
+                    this.addSchemaValueCompletions(schema.schema, separatorAfter, collector, {}, 'property', Array.isArray(nodeParent.items));
                 }
                 if (schema.schema.propertyNames && schema.schema.additionalProperties && schema.schema.type === 'object') {
                     const propertyNameSchema = asSchema(schema.schema.propertyNames);
@@ -688,7 +721,7 @@ export class YamlCompletion {
             node = doc.getParent(node);
         }
         if (!node) {
-            this.addSchemaValueCompletions(schema.schema, '', collector, types);
+            this.addSchemaValueCompletions(schema.schema, '', collector, types, 'value');
             return;
         }
         if (isPair(node)) {
@@ -714,54 +747,26 @@ export class YamlCompletion {
                             if (Array.isArray(s.schema.items)) {
                                 const index = this.findItemAtOffset(node, document, offset);
                                 if (index < s.schema.items.length) {
-                                    this.addSchemaValueCompletions(s.schema.items[index], separatorAfter, collector, types);
+                                    this.addSchemaValueCompletions(s.schema.items[index], separatorAfter, collector, types, 'value');
                                 }
                             }
-                            else if (typeof s.schema.items === 'object' && s.schema.items.type === 'object') {
-                                const insertText = `- ${this.getInsertTextForObject(s.schema.items, separatorAfter, '  ').insertText.trimLeft()}`;
-                                const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${s.schema.description ? ' (' + s.schema.description + ')' : ''}`, insertText);
-                                collector.add({
-                                    kind: this.getSuggestionKind(s.schema.items.type),
-                                    label: '- (array item)',
-                                    documentation,
-                                    insertText,
-                                    insertTextFormat: InsertTextFormat.Snippet,
-                                });
-                                this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types);
-                            }
-                            else if (typeof s.schema.items === 'object' && s.schema.items.anyOf) {
-                                s.schema.items.anyOf
-                                    .filter((i) => typeof i === 'object')
-                                    .forEach((i, index) => {
-                                    const schemaType = getSchemaTypeName(i);
-                                    const insertText = `- ${this.getInsertTextForObject(i, separatorAfter).insertText.trimLeft()}`;
-                                    //append insertText to documentation
-                                    const schemaTypeTitle = schemaType ? ' type `' + schemaType + '`' : '';
-                                    const schemaDescription = s.schema.description ? ' (' + s.schema.description + ')' : '';
-                                    const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${schemaTypeTitle}${schemaDescription}`, insertText);
-                                    collector.add({
-                                        kind: this.getSuggestionKind(i.type),
-                                        label: '- (array item) ' + (schemaType || index + 1),
-                                        documentation: documentation,
-                                        insertText: insertText,
-                                        insertTextFormat: InsertTextFormat.Snippet,
-                                    });
-                                });
-                                this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types);
+                            else if (typeof s.schema.items === 'object' &&
+                                (s.schema.items.type === 'object' || isAnyOfAllOfOneOfType(s.schema.items))) {
+                                this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types, 'value', true);
                             }
                             else {
-                                this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types);
+                                this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types, 'value');
                             }
                         }
                     }
                     if (s.schema.properties) {
                         const propertySchema = s.schema.properties[parentKey];
                         if (propertySchema) {
-                            this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
+                            this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types, 'value');
                         }
                     }
                     else if (s.schema.additionalProperties) {
-                        this.addSchemaValueCompletions(s.schema.additionalProperties, separatorAfter, collector, types);
+                        this.addSchemaValueCompletions(s.schema.additionalProperties, separatorAfter, collector, types, 'value');
                     }
                 }
             }
@@ -774,6 +779,21 @@ export class YamlCompletion {
             }
         }
     }
+    addArrayItemValueCompletion(schema, separatorAfter, collector, index) {
+        const schemaType = getSchemaTypeName(schema);
+        const insertText = `- ${this.getInsertTextForObject(schema, separatorAfter).insertText.trimLeft()}`;
+        //append insertText to documentation
+        const schemaTypeTitle = schemaType ? ' type `' + schemaType + '`' : '';
+        const schemaDescription = schema.description ? ' (' + schema.description + ')' : '';
+        const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${schemaTypeTitle}${schemaDescription}`, insertText);
+        collector.add({
+            kind: this.getSuggestionKind(schema.type),
+            label: '- (array item) ' + (schemaType || index),
+            documentation: documentation,
+            insertText: insertText,
+            insertTextFormat: InsertTextFormat.Snippet,
+        });
+    }
     getInsertTextForProperty(key, propertySchema, separatorAfter, indent = this.indentation) {
         const propertyText = this.getInsertTextForValue(key, '', 'string');
         const resultText = propertyText + ':';
@@ -944,7 +964,9 @@ export class YamlCompletion {
                     case 'boolean':
                     case 'number':
                     case 'integer':
-                        insertText += `${indent}${key}: \${${insertIndex++}:${propertySchema.default}}\n`;
+                        insertText += `${indent}${
+                        //added quote if key is null
+                        key === 'null' ? this.getInsertTextForValue(key, '', 'string') : key}: \${${insertIndex++}:${propertySchema.default}}\n`;
                         break;
                     case 'string':
                         insertText += `${indent}${key}: \${${insertIndex++}:${convertToStringValue(propertySchema.default)}}\n`;
@@ -1073,24 +1095,28 @@ export class YamlCompletion {
         }
         return this.getInsertTextForPlainText(value + separatorAfter);
     }
-    addSchemaValueCompletions(schema, separatorAfter, collector, types, isArray) {
+    addSchemaValueCompletions(schema, separatorAfter, collector, types, completionType, isArray) {
         if (typeof schema === 'object') {
             this.addEnumValueCompletions(schema, separatorAfter, collector, isArray);
             this.addDefaultValueCompletions(schema, separatorAfter, collector);
             this.collectTypes(schema, types);
+            if (isArray && completionType === 'value' && !isAnyOfAllOfOneOfType(schema)) {
+                // add array only for final types (no anyOf, allOf, oneOf)
+                this.addArrayItemValueCompletion(schema, separatorAfter, collector);
+            }
             if (Array.isArray(schema.allOf)) {
                 schema.allOf.forEach((s) => {
-                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types);
+                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types, completionType, isArray);
                 });
             }
             if (Array.isArray(schema.anyOf)) {
                 schema.anyOf.forEach((s) => {
-                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types);
+                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types, completionType, isArray);
                 });
             }
             if (Array.isArray(schema.oneOf)) {
                 schema.oneOf.forEach((s) => {
-                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types);
+                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types, completionType, isArray);
                 });
             }
         }
@@ -1263,7 +1289,7 @@ export class YamlCompletion {
             }
             return value;
         };
-        return stringifyObject(value, '', replacer, Object.assign(Object.assign({}, settings), { indentation: this.indentation }), depth) + separatorAfter;
+        return stringifyObject(value, '', replacer, { ...settings, indentation: this.indentation }, depth) + separatorAfter;
     }
     addBooleanValueCompletion(value, separatorAfter, collector) {
         collector.add({
@@ -1430,8 +1456,7 @@ function convertToStringValue(param) {
  * simplify `{$1:value}` to `value`
  */
 function evaluateTab1Symbol(value) {
-    const result = value.replace(/\$\{1:(.*)\}/, '$1');
-    return result;
+    return value.replace(/\$\{1:(.*)\}/, '$1');
 }
 function isParentCompletionItem(item) {
     return 'parent' in item;