public runNormalMode(ctrl: IController, ed:TextEditor, repeatCount: number, args: string): boolean {
		let register = ctrl.getDeleteRegister();
		if (!register) {
			// No delete register - beep!!
			return true;
		}

		let str = repeatString(register.content, repeatCount);

		let pos = this.pos(ed);
		if (!register.isWholeLine) {
			ed.edit((builder) => {
				builder.insert(new Position(pos.line, pos.character + 1), str);
			});
			return true;
		}

		let doc = this.doc(ed);
		let insertLine = pos.line + 1;
		let insertCharacter = 0;

		if (insertLine >=  doc.lineCount) {
			// on last line
			insertLine = doc.lineCount - 1;
			insertCharacter = doc.lineAt(insertLine).text.length;
			str = '\n' + str;
		}

		ed.edit((builder) => {
			builder.insert(new Position(insertLine, insertCharacter), str);
		});

		return true;
	}

    async restore(editor: TextEditor) {
        // If the editor isn't disposed then we don't need to do anything
        // Explicitly check for `false`
        if ((this.editor as any)._disposed === false) return;

        this.status = AnnotationStatus.Computing;
        if (editor === window.activeTextEditor) {
            await setCommandContext(CommandContext.AnnotationStatus, this.status);
        }

        this.editor = editor;
        this.correlationKey = AnnotationProviderBase.getCorrelationKey(editor);
        this.document = editor.document;

        if (this.decorations !== undefined && this.decorations.length) {
            this.editor.setDecorations(this.decoration, this.decorations);

            if (this.additionalDecorations !== undefined && this.additionalDecorations.length) {
                for (const d of this.additionalDecorations) {
                    this.editor.setDecorations(d.decoration, d.ranges);
                }
            }
        }

        this.status = AnnotationStatus.Computed;
        if (editor === window.activeTextEditor) {
            await setCommandContext(CommandContext.AnnotationStatus, this.status);
        }
    }

function updateCSSNode(editor: TextEditor, property: Property): Thenable<boolean> {
	const rule: Rule = property.parent;
	let currentPrefix = '';

	// Find vendor prefix of given property node
	for (let i = 0; i < vendorPrefixes.length; i++) {
		if (property.name.startsWith(vendorPrefixes[i])) {
			currentPrefix = vendorPrefixes[i];
			break;
		}
	}

	const propertyName = property.name.substr(currentPrefix.length);
	const propertyValue = property.value;

	return editor.edit(builder => {
		// Find properties with vendor prefixes, update each
		vendorPrefixes.forEach(prefix => {
			if (prefix === currentPrefix) {
				return;
			}
			let vendorProperty = getCssPropertyFromRule(rule, prefix + propertyName);
			if (vendorProperty) {
				builder.replace(new Range(vendorProperty.valueToken.start, vendorProperty.valueToken.end), propertyValue);
			}
		});
	});
}

export default async function px2em(textEditor: TextEditor, lastValue: string | undefined) {
  const doc = textEditor.document;
  const selections = getValidSelections(textEditor, doc);

  if (selections.length === 0) { return; }

  textEditor.selections = selections;

  let option: InputBoxOptions = {
    placeHolder: '请输入font-size的基准值',
    prompt: '单位为px或rem，当单位为px时，可省略px。',
    value: lastValue,
  };

  let input = await window.showInputBox(option);
  if (hasInvalidInput(input)) { return; }

  let match = input.match(regex) as RegExpMatchArray;
  let factor = +match[1];
  let unit = match[2];

  if (!unit) { unit = 'px'; }
  lastValue = factor + unit;

  if (unit === 'rem') { factor *= config.htmlFontSize; }

  textEditor.edit((edit) => {
    convert(textEditor, edit, factor, 'em');
  });

  return lastValue;
}

/**
 * Applies the given set of patches to the document in the given editor
 *
 * @param patches array of patches to be applied
 * @param editor the TextEditor whose document will be updated
 */
function applypatches(patches: dmp.Patch[], editor: TextEditor): Thenable<boolean> {
	let totalEdits: Edit[] = [];
	patches.reverse().forEach((patch: dmp.Patch) => {
		// Godoctor provides a diff for each line, but the text accompanying the diff does not end with '\n'
		// GetEditsFromDiffs(..) expects the '\n' to exist in the text wherever there is a new line.
		// So add one for each diff from getdoctor
		for (let i = 0; i < patch.diffs.length; i++) {
			patch.diffs[i][1] += '\n';
		}
		let edits = GetEditsFromDiffs(patch.diffs, patch.start1);
		totalEdits = totalEdits.concat(edits);
	});

	return editor.edit((editBuilder) => {
		totalEdits.forEach((edit) => {
			switch (edit.action) {
				case EditTypes.EDIT_INSERT:
					editBuilder.insert(edit.start, edit.text);
					break;
				case EditTypes.EDIT_DELETE:
					editBuilder.delete(new Range(edit.start, edit.end));
					break;
				case EditTypes.EDIT_REPLACE:
					editBuilder.replace(new Range(edit.start, edit.end), edit.text);
					break;
			}
		});
	});
}

	public runVisualMode(ctrl: IController, ed:TextEditor, args: string): boolean {
		if (args.length === 0) {
			// input not ready
			return false;
		}

		let doc = this.doc(ed);
		let sel = this.sel(ed);

		let srcString = doc.getText(sel);
		let dstString = '';
		for (let i = 0; i < srcString.length; i++) {
			let ch = srcString.charAt(i);
			if (ch === '\r' || ch === '\n') {
				dstString += ch;
			} else {
				dstString += args;
			}
		}

		ed.edit((builder) => {
			builder.replace(sel, dstString);
		});

		return true;
	}

export function update_editor(editor: TextEditor)
{
  if (editor) {
    const decorations = document_decorations.get(editor.document.uri.toString())
    if (decorations) {
      for (const [typ, content] of decorations) {
        editor.setDecorations(types.get(typ), content)
      }
    }
  }
}

 const setText = async function (editor: TextEditor, text: string) {
     return editor.edit((editBuilder: TextEditorEdit) => {
         const doc = editor.document;
         const startPos = new Position(0, 0);
         const lastLine = doc.lineAt(doc.lineCount - 1);
         const endPos = lastLine.range.end;
         const entireRange = new Range(startPos, endPos);
         editBuilder.replace(entireRange, text);
         editBuilder.setEndOfLine(EndOfLine.LF);
     });
 };

    clear() {
        this.status = undefined;
        if (this.editor === undefined) return;

        if (this.decoration !== undefined) {
            try {
                this.editor.setDecorations(this.decoration, []);
            }
            catch {}
        }

        if (this.additionalDecorations !== undefined && this.additionalDecorations.length > 0) {
            for (const d of this.additionalDecorations) {
                try {
                    this.editor.setDecorations(d.decoration, []);
                }
                catch {}
            }

            this.additionalDecorations = undefined;
        }

        if (this.highlightDecoration !== undefined) {
            try {
                this.editor.setDecorations(this.highlightDecoration, []);
            }
            catch {}
        }
    }

			.then((res: DocCommandTemplateResponse) => {
				if (!res || !res.body) {
					return false;
				}
				return editor.insertSnippet(
					this.templateToSnippet(res.body.newText),
					position,
					{ undoStopBefore: false, undoStopAfter: true });
			}, () => false);