const applyReplacement = (editor: Editor, target: Text, match: ReplacementMatch) => {
  target.deleteData(match.startOffset, match.pattern.start.length);
  editor.insertContent(match.pattern.replacement);

  Option.from(target.nextSibling).filter(isText).each((nextSibling: Text) => {
    nextSibling.insertData(0, target.data);
    editor.dom.remove(target);
  });
};

const mergeTextNodes = (prevNode: Text, nextNode: Text, normalizeWhitespace?: boolean): Text => {
  const whitespaceOffset = Strings.rTrim(prevNode.data).length;
  // Merge the elements
  prevNode.appendData(nextNode.data);
  Remove.remove(Element.fromDom(nextNode));

  // Normalize the whitespace around the merged elements, to ensure it doesn't get lost
  if (normalizeWhitespace) {
    normalizeWhitespaceAfter(prevNode, whitespaceOffset);
  }

  return prevNode;
};

const normalize = (node: Text, offset: number, count: number) => {
  if (count === 0) {
    return;
  }

  // Get the whitespace
  const whitespace = node.data.slice(offset, offset + count);

  // Determine if we're at the end of start of the content
  const isEndOfContent = offset + count >= node.data.length;
  const isStartOfContent = offset === 0;

  // Replace the original whitespace with the normalized whitespace content
  node.replaceData(offset, count, normalizeContent(whitespace, isStartOfContent, isEndOfContent));
};

const applyBlockPattern = (editor: Editor, pattern: BlockPattern) => {
  const dom = editor.dom;
  const rng = editor.selection.getRng();
  const block = dom.getParent(rng.startContainer, dom.isBlock);
  if (!block || !dom.is(block, 'p') || !isElement(block)) {
    return;
  }

  const walker = new TreeWalker(block, block);
  let node: Node;
  let firstTextNode: Text;
  while ((node = walker.next())) {
    if (isText(node)) {
      firstTextNode = node;
      break;
    }
  }
  if (!firstTextNode) {
    return;
  }
  if (!Strings.startsWith(firstTextNode.data, pattern.start)) {
    return;
  }
  if (Tools.trim(block.textContent).length === pattern.start.length) {
    return;
  }

  // add a marker to store the cursor position
  const cursor = editor.selection.getBookmark();
  if (pattern.type === 'block-format') {
    if (isBlockFormatName(pattern.format, editor.formatter)) {
      editor.undoManager.transact(() => {
        firstTextNode.deleteData(0, pattern.start.length);
        editor.formatter.apply(pattern.format);
      });
    }
  } else if (pattern.type === 'block-command') {
    editor.undoManager.transact(() => {
      firstTextNode.deleteData(0, pattern.start.length);
      editor.execCommand(pattern.cmd, false, pattern.value);
    });
  }
  // return the selection
  editor.selection.moveToBookmark(cursor);
};

const prependData = (target: Text, data: string): void => {
  target.insertData(0, data);
};

 editor.undoManager.transact(() => {
   firstTextNode.deleteData(0, pattern.start.length);
   editor.execCommand(pattern.cmd, false, pattern.value);
 });

const insertInline = (before: boolean, node: Node) => before ? insertBefore(node) : insertAfter(node);