let result = pEntityRef().run(@combinator.Seq::from_string("<"))
  inspect(result, content="Some((\"<\", ))")

• input : A sequence of characters representing the XML attribute to be parsed. The sequence should start with a valid XML name followed by "=" and a double-quoted string value.

• Succeeds with a tuple containing the attribute name and value if parsing is successful
• Fails if the input does not match the expected XML attribute format

  let result = pattribute().run(@combinator.Seq::from_string("name=\"value\""))
  inspect(result, content="Some(((\"name\", \"value\"), ))")

  let result = pattributes().run(
    @combinator.Seq::from_string(" name=\"value\" type=\"text\""),
  )
  let attrs = result.unwrap().0
  inspect(attrs.get("name"), content="Some(\"value\")")
  inspect(attrs.get("type"), content="Some(\"text\")")

• seq : The input sequence of characters to be parsed. Expected to start with a CDATA section.

  let input = "<![CDATA[Some <raw> XML & content]]>"
  let result = pcdata().run(@combinator.Seq::from_string(input))
  inspect(result, content="Some((\"Some <raw> XML & content\", ))")

  let input = "<![CDATA[]]>"
  let result = pcdata().run(@combinator.Seq::from_string(input))
  inspect(result, content="Some((\"\", ))")

• For decimal references, matches patterns like "{"
• For hexadecimal references, matches patterns like "¥"
• Returns the matched reference as a string, including the delimiters

  let decimal = pcharRef().run(@combinator.Seq::from_string("{"))
  let hex = pcharRef().run(@combinator.Seq::from_string("¥"))
  inspect(decimal, content="Some((\"#123;\", ))")
  inspect(hex, content="Some((\"#A5;\", ))")

• seq : A sequence of characters representing the XML content to be parsed. The sequence should start with an XML comment.

  let comment = "<!-- This is a comment -->"
  let result = pcomment().run(@combinator.Seq::from_string(comment))
  inspect(result, content="Some((\" This is a comment \", ))")

• Succeeds with the contents of the DTD declaration as a string, excluding the opening "<!" and closing ">" delimiters
• Fails if the input doesn't match the expected DTD format

  let result = pdtd().run(@combinator.Seq::from_string("<!DOCTYPE html>")).unwrap().0
  inspect(result, content="<!DOCTYPE html>")

• input : A sequence of characters representing an XML element. The sequence should start with an opening tag (e.g., <tag>) and end with either a self-closing tag (e.g., />) or a matching closing tag (e.g., </tag>).

• The element's name
• A map of attribute names to their values
• A queue of child nodes (XMLChildren)

  // Parse a simple XML element with attributes and text content
  let input = "<user id=\"1\" name=\"John\">Hello, World!</user>"
  let result = pelement().run(@combinator.Seq::from_string(input))
  let element = result.unwrap().0
  inspect(element.name, content="user")
  inspect(element.attributes.get("id"), content="Some(\"1\")")
  inspect(element.attributes.get("name"), content="Some(\"John\")")

  // Valid XML names
  let result1 = pname().run(@combinator.Seq::from_string("element1"))
  inspect(result1, content="Some((\"element1\", ))")

  // Invalid XML names (starting with digit)
  let result2 = pname().run(@combinator.Seq::from_string("1element"))
  inspect(result2, content="None")

• Succeeds with the content of the processing instruction (excluding the "" delimiters) if a valid PI is found
• Fails if the input does not start with a valid processing instruction

  let result = ppi().run(@combinator.Seq::from_string("<?php echo 'Hello' ?>"))
  inspect(result, content="Some((\"php echo 'Hello' \", ))")

  let result = ppi().run(@combinator.Seq::from_string("<??>"))
  inspect(result, content="Some((\"\", ))")

  let result = ppi().run(@combinator.Seq::from_string("<?incomplete"))
  inspect(result, content="None")

• Succeeds with a map containing prolog attributes if the input starts with a valid XML prolog
• Fails if the input does not match the XML prolog syntax: <?xmlattr1="value1" attr2="value2"?>

  // Entity reference
  let entity = preference().run(@combinator.Seq::from_string("&"))
  inspect(entity, content="Some((\"&\", ))")

  // Character reference (decimal)
  let decimal = preference().run(@combinator.Seq::from_string(" "))
  inspect(decimal, content="Some((\"#32;\", ))")

  // Character reference (hexadecimal)
  let hex = preference().run(@combinator.Seq::from_string(" "))
  inspect(hex, content="Some((\"#20;\", ))")

• input : A sequence of characters to be parsed. Should not contain any instances of '<' or '&'.

• Succeeds and produces a String representing the concatenated characters that are not '<' or '&'.
• Fails if any character in the sequence is '<' or '&'.

  let result = ptext().run(@combinator.Seq::from_string("Hello World"))
  inspect(result, content="Some((\"Hello World\", ))")

  let result = ptext().run(@combinator.Seq::from_string("Text with & and <"))
  inspect(result, content="Some((\"Text with \", '&'' ''a''n''d'' ''<'))") // stops parsing at '&'

  let result = ptext().run(@combinator.Seq::from_string(""))
  inspect(result, content="Some((\"\", ))")

• Consumes zero or more whitespace characters.
• Concatenates all consumed whitespace characters into a single string.
• Returns the concatenated string.

  let result = pwhite_space().run(@combinator.Seq::from_string("  \t\n\rtext"))
  inspect(result, content="Some((\"  \\t\\n\\r\", 't''e''x''t'))")

• seq : A sequence of characters representing the XML document to be parsed. Should contain optional XML prolog, optional DOCTYPE declaration, and exactly one root element.

• Succeeds with an XMLDocument containing version (defaults to "1.0"), encoding (defaults to "UTF-8"), standalone flag, and the parsed root element.
• Fails if the input is not a well-formed XML document.

  let xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><root><child>Text</child></root>"
  let result = pxml().run(@combinator.Seq::from_string(xml))
  let doc = result.unwrap().0
  inspect(doc.version, content="1.0")
  inspect(doc.root.name, content="root")

• xml_string : A string containing the XML document to be parsed.

  let xml = "<?xml version=\"1.0\"?><root><child>Content</child></root>"
  let doc = xml_from_string(xml).unwrap()
  inspect(doc.root.name, content="root")