docs: def parse(self, string, root=None):
  
  		"""
  		Parses a string to handle escaped tags and retrieve phrases.
  
  		This method works recursively to parse nested tags. When escaped
  		tags are found, those are removed from the string. Also argument
  		sequences are removed from the string. The string returned can
  		thus be quite different from the string passed.
  
  		Arguments:
  			string (str): The string to parse.
  			root (Phrase): If in a recursive call, the root/parent phrase.
  
  		Returns:
  			For one, the escaped string (without escape characters and
  			phrase arguments). For the other, it depends on the stack-depth.
  			If this is the lowest recursion depth/level (i.e. the stack
  			call resulting from the first function call in self.beautify()),
  			it will return a list of phrases. For higher stack levels (
  			i.e. resulting from recursive function calls from with
  			self.parse(), for nested phrases), it returns exactly one
  			Phrase instance.
  
  		Raises:
  			errors.ParseError: If no closing tag could be
  							   found for an opening tag.
  		"""
  
  		phrases = []
  
  		meta = self.meta.search(string)
  
  		while meta:
  
  			# Save some function calls
  			pos = meta.start()
  
  			if meta.group() == "<":
  				string, child, meta = self.open_phrase(string, pos)
  
  				if child and root:
  					root.nested.append(child)
  				elif child:
  					phrases.append(child)
  
  				# else it was escaped (+ new meta)
  				continue
  
  			elif root:
  
  				if meta.group() == "(":
  					meta = self.meta.search(string, pos + 1)
  					if meta.group() == ")":
  						string, root, meta = self.handle_arguments(string,
  																   root,
  																   pos,
  																   meta.start())
  						continue
  
  				elif meta.group() == ">":
  					string, phrase, meta = self.close_phrase(string,
  															 root,
  															 pos)
  					if phrase:
  						return string, phrase
  
  					# else was escaped (+ new meta)
  					continue
  
  			string, meta = self.escape_meta(string, pos)
  
  		if not root:
  			return string, phrases
  
  		# If this is not the first stack-depth the function should
  		# have returned upon finding a closing tag,
  		# i.e. we should never have gotten here.
  		word = re.search(r"([\w\s]+)(?![\d]*>[\w\s]+>)", string)
  
  		what = "No closing tag found for opening tag"
  
  		if word:
  			what += " after expression '{0}'".format(word.group())
  
  		raise errors.ParseError(what + "!")