test {
  let result = @XMLParser.pEntityRef().run(@combinator.Seq::from_string("<"))
  debug_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

test {
  let result = @XMLParser.pattribute().run(@combinator.Seq::from_string("name=\"value\""))
  debug_inspect(
    result,
    content=(
      #|Some((("name", "value")))
    ),
  )
}

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

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

test {
  let input = "<![CDATA[Some <raw> XML & content]]>"
  let result = @XMLParser.pcdata().run(@combinator.Seq::from_string(input))
  debug_inspect(
    result,
    content=(
      #|Some(("Some <raw> XML & content"))
    ),
  )
  let input = "<![CDATA[]]>"
  let result = @XMLParser.pcdata().run(@combinator.Seq::from_string(input))
  debug_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

test {
  let decimal = @XMLParser.pcharRef().run(@combinator.Seq::from_string("{"))
  let hex = @XMLParser.pcharRef().run(@combinator.Seq::from_string("¥"))
  debug_inspect(
    decimal,
    content=(
      #|Some(("#123;"))
    ),
  )
  debug_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.

test {
  let comment = "<!-- This is a comment -->"
  let result = @XMLParser.pcomment().run(@combinator.Seq::from_string(comment))
  debug_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

test {
  let result = @XMLParser.pdtd()
    .run(@combinator.Seq::from_string("<!DOCTYPE html>"))
    .unwrap().0
  debug_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)

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

test {
  // Valid XML names
  let result1 = @XMLParser.pname().run(@combinator.Seq::from_string("element1"))
  debug_inspect(
    result1,
    content=(
      #|Some(("element1"))
    ),
  )

  // Invalid XML names (starting with digit)
  let result2 = @XMLParser.pname().run(@combinator.Seq::from_string("1element"))
  debug_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

test {
  let result = @XMLParser.ppi().run(@combinator.Seq::from_string("<?php echo 'Hello' ?>"))
  debug_inspect(
    result,
    content=(
      #|Some(("php echo 'Hello' "))
    ),
  )
  let result = @XMLParser.ppi().run(@combinator.Seq::from_string("<??>"))
  debug_inspect(
    result,
    content=(
      #|Some((""))
    ),
  )
  let result = @XMLParser.ppi().run(@combinator.Seq::from_string("<?incomplete"))
  debug_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"?>

test {
  // Entity reference
  let entity = @XMLParser.preference().run(@combinator.Seq::from_string("&"))
  debug_inspect(
    entity,
    content=(
      #|Some(("&"))
    ),
  )

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

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

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