ion.
	 */
	remove( modelPosition ) {
		// By default we take the node which matches the position index.
		let index = modelPosition.index;

		// If we're inside a text node though, it means that the removed node was actually
		// after that text node, so we fix the index. To illustrate (e.g.):
		//
		// 	Index:  0          1         2
		//	Before: text-before|{removed}text-after -> | == position.index = 1
		//
		// 	Index:  0
		//	After: text-before|text-after -> | == position.index = 0
		//
		const inTextNode = modelPosition.textNode;
		if ( inTextNode ) {
			index = modelPosition.textNode.index + 1;
		}

		const parent = this.getNode( modelPosition.parent );
		parent[ $children ].splice( index, 1 );

		if ( !parent[ $children ].length ) {
			delete parent[ $children ];
		}

		// As demonstrated in the above comment, text need to be refreshed as they where merged.
		if ( inTextNode ) {
			this.refreshTexts( modelPosition.parent );
		}
	}

	/**
	 * Refreshes a node. This is useful when changes to attributes happen.
	 *
	 * @param modelNode {Element|Text} The node to be refreshed.
	 */
	refreshNode( modelNode ) {
		this.updateDefinition( this.getNode( modelNode ), modelNode );
	}

	/**
	 * Removes and re-inserts all text nodes that are direct children of an element.
	 *
	 * @param modelNode {Element} The parent element.
	 */
	refreshTexts( modelNode ) {
		const node = this.getNode( modelNode );
		const children = node[ $children ] || [];

		// Remove all text nodes.
		for ( let i = children.length - 1; i >= 0; i-- ) {
			if ( $text in children[ i ] ) {
				children.splice( i, 1 );
			}
		}

		// Insert all text nodes back again.
		Array.from( modelNode.getChildren() ).forEach( child => {
			if ( child.is( '$text' ) ) {
				children.splice( child.index, 0, this.getDefinition( child ) );
			}
		} );

		if ( children.length ) {
			node[ $children ] = children;
		} else {
			delete node[ $children ];
		}
	}

	/**
	 * Fills up a node definition, not including children nodes.
	 *
	 * @param definition {Object}
	 * @para