.then(() => {
     if (content) {
         return window.activeTextEditor.edit(editBuilder => {
             editBuilder.insert(new Position(0, 0), content);
         });
     }
 });

function addImportStatementToCurrentFile(item: QuickPickItem, config: Config) {
    const statementES6 = `import {} from ${config.importQuotes}${item.label}${config.importQuotes}${config.importLinebreak}`;
    const statementRequire = `${config.importDeclarationType} ${guessVariableName(item.label)} = require(${config.importQuotes}${item.label}${config.importQuotes})${config.importLinebreak}`;
    const statement = config.importES6 ? statementES6 : statementRequire;
    const insertLocation = window.activeTextEditor.selection.start;
    window.activeTextEditor.edit(edit => edit.insert(insertLocation, statement));
}

    public async complete(): Promise<void> {
        if (this.langClient === undefined) {
            return;
        }

        const triggerStartPos = this.lastChangeRange.start;
        const doc = this.lastDocument;

        const result = await this.langClient.sendRequest(CommentHelpRequestType, {
            documentUri: doc.uri.toString(),
            triggerPosition: triggerStartPos,
            blockComment: this.settings.helpCompletion === Settings.HelpCompletion.BlockComment,
        });

        if (!(result && result.content)) {
            return;
        }

        const replaceRange = new Range(triggerStartPos.translate(0, -1), triggerStartPos.translate(0, 1));

        // TODO add indentation level to the help content
        // Trim leading whitespace (used by the rule for indentation) as VSCode takes care of the indentation.
        // Trim the last empty line and join the strings.
        const lines: string[] = result.content;
        const text = lines
            .map((x) => (x as any).trimLeft())
            .join(this.getEOL(doc.eol));

        const snippetString = new SnippetString(text);

        window.activeTextEditor.insertSnippet(snippetString, replaceRange);
    }

			tagProvider(document, position).then(text => {
				if (text && isEnabled) {
					let activeDocument = window.activeTextEditor && window.activeTextEditor.document;
					if (document === activeDocument && activeDocument.version === version) {
						window.activeTextEditor.insertSnippet(new SnippetString(text), position);
					}
				}
			});

 private async moveCaretDown() {
     // Take focus back to the editor
     window.activeTextEditor.show();
     const selectionEmpty = window.activeTextEditor.selection.isEmpty;
     if (selectionEmpty) {
         await commands.executeCommand("cursorMove",
             {
                 by: "line",
                 to: "down",
             });
     }
 }

function toggle(lines: TextLine[], check: string = ';') {
    let firstToggle = -1; // -1 = not yet, 0 = remove, 1 = insert
    window.activeTextEditor.edit((editBuilder) => {
        lines.forEach(line => {
            let found = line.text.slice(-1 * check.length) === check;
            let shouldRemove = (follow && found && firstToggle !== 1) || (!follow && found);
            let shouldInsert = (follow && !found && firstToggle !== 0) || (!follow && !found);
            shouldRemove && remove(editBuilder, line, check);
            !shouldRemove && shouldInsert && insert(editBuilder, line, check);
            firstToggle = firstToggle === -1 ? found ? 0 : 1 : -1;
        });
    });
}

 textEdits.forEach((te) => {
     window.activeTextEditor.edit((textEditorEdit: TextEditorEdit) => {
         textEditorEdit.replace(te.range, te.newText);
     });
 });