🥮 mooncakes.io

    html

    A fast, lossless HTML parser with source offsets, CSS selectors, and an optional mutable tree

    html
    parser
    dom
    css
    selector
    Download zip
    Author
    Version
    0.1.1
    License
    MIT
    Repository
    Last updated
    18 hours ago
    Downloads
    12

    No dependencies

    #justjavac/html

    coverage

    Fast, lossless HTML parsing with UTF-16 source offsets, lazy entity decoding, CSS selectors, and an optional mutable tree. Supports native, js, wasm, and wasm-gc.

    #Install

    moon add justjavac/html

    #Quick Start

    ///|
    test "parse and query HTML" {
      let doc = @html.parse(
        "<head><title>Hi &amp; bye</title><link rel=canonical href=\"/\"></head>",
      )
      inspect(doc.find("head > title").unwrap().text(), content="Hi & bye")
      assert_eq(
        doc.find("link[rel=canonical]").unwrap().get_attr("href"),
        Some("/"),
      )
      let title = doc.find("title").unwrap()
      assert_eq(doc.position(title.start()), { line: 1, column: 7, })
      inspect(title.stringify(), content="<title>Hi &amp; bye</title>")
    }

    #Mutable Trees

    Import justjavac/html/mutable for attribute, text, and child edits. Mutable nodes preserve untouched source and rebuild only edited branches.

    This package follows htmlparser2-style recovery, not the WHATWG tree-construction algorithm. Do not use it as an HTML sanitizer.

    Stringify

    source
    pub trait Stringify {
      fn stringify(Self) -> String
    }

    Values that can be serialized back to their exact original HTML source.

    SelectorError

    source
    pub suberror SelectorError {
      InvalidSelector(String)
    }

    A malformed or unsupported CSS selector.

    Comment

    source
    pub struct Comment {
      // private fields
    }

    A normal or bogus comment.
    impl Eq for Comment
    impl Debug for Comment

    Comment::document

    source
    fn Comment::document(self : Comment) -> Document

    Comment::end

    source
    fn Comment::end(self : Comment) -> Int

    Comment::equal

    source
    #deprecated("Use the Eq trait directly")
    fn Comment::equal(self : Comment, other : Comment) -> Bool

    Comment::not_equal

    source
    #deprecated("Use the Eq trait directly")
    fn Comment::not_equal(x : Comment, y : Comment) -> Bool

    Comment::parent

    source
    fn Comment::parent(self : Comment) -> Parent

    Comment::start

    source
    fn Comment::start(self : Comment) -> Int

    Comment::stringify

    source
    fn Comment::stringify(self : Comment) -> String

    Comment::to_repr

    source
    #deprecated("Use the Debug trait directly")
    fn Comment::to_repr(self : Comment) -> 
    Repr

    Comment::value

    source
    fn Comment::value(self : Comment) -> String

    Directive

    source
    pub struct Directive {
      // private fields
    }

    A doctype declaration.
    impl Eq for Directive
    impl Debug for Directive

    Directive::document

    source
    fn Directive::document(self : Directive) -> Document

    Directive::end

    source
    fn Directive::end(self : Directive) -> Int

    Directive::equal

    source
    #deprecated("Use the Eq trait directly")
    fn Directive::equal(self : Directive, other : Directive) -> Bool

    Directive::not_equal

    source
    #deprecated("Use the Eq trait directly")
    fn Directive::not_equal(x : Directive, y : Directive) -> Bool

    Directive::parent

    source
    fn Directive::parent(self : Directive) -> Parent

    Directive::start

    source
    fn Directive::start(self : Directive) -> Int

    Directive::stringify

    source
    fn Directive::stringify(self : Directive) -> String

    Directive::to_repr

    source
    #deprecated("Use the Debug trait directly")
    fn Directive::to_repr(self : Directive) -> 
    Repr

    Directive::value

    source
    fn Directive::value(self : Directive) -> String

    Document

    source
    pub struct Document {
      // private fields
    }

    An HTML document produced by parse.
    impl Eq for Document
    impl Debug for Document

    Document::all

    source
    fn Document::all(self : Document, selector : String) -> Array[Element] raise SelectorError

    Find all matching elements in source order.

    Document::all_with

    source
    fn Document::all_with(self : Document, selector : Selector) -> Array[Element]

    Find all elements using a selector compiled by Selector::parse.

    Document::children

    source
    fn Document::children(self : Document) -> Array[Node]

    Top-level nodes in source order.

    Document::end

    source
    fn Document::end(self : Document) -> Int

    Document::equal

    source
    #deprecated("Use the Eq trait directly")
    fn Document::equal(self : Document, other : Document) -> Bool

    Document::find

    source
    fn Document::find(self : Document, selector : String) -> Element? raise SelectorError

    Find the first matching element, or return None.

    Document::find_with

    source
    fn Document::find_with(self : Document, selector : Selector) -> Element?

    Find the first element using a selector compiled by Selector::parse.

    Document::not_equal

    source
    #deprecated("Use the Eq trait directly")
    fn Document::not_equal(x : Document, y : Document) -> Bool

    Document::position

    source
    fn Document::position(self : Document, offset : Int) -> Position

    Convert a UTF-16 source offset to a one-based line and column.

    Document::source

    source
    fn Document::source(self : Document) -> String

    The exact source from which this document was parsed.

    Document::start

    source
    fn Document::start(_self : Document) -> Int

    Document::stringify

    source
    fn Document::stringify(self : Document) -> String

    Document::text

    source
    fn Document::text(self : Document) -> String

    The decoded text of all text nodes in document order.

    Document::to_repr

    source
    #deprecated("Use the Debug trait directly")
    fn Document::to_repr(self : Document) -> 
    Repr

    Element

    source
    pub struct Element {
      // private fields
    }

    An element handle. Handles are cheap views into the document's compact tree.
    impl Eq for Element
    impl Debug for Element

    Element::all

    source
    fn Element::all(self : Element, selector : String) -> Array[Element] raise SelectorError

    Element::all_with

    source
    fn Element::all_with(self : Element, selector : Selector) -> Array[Element]

    Find all descendants using a precompiled selector.

    Element::attributes

    source
    fn Element::attributes(self : Element) -> Map[String, String]

    Return an independent map of lowercase attribute names and decoded values.

    Element::children

    source
    fn Element::children(self : Element) -> Array[Node]

    Element::closest

    source
    fn Element::closest(self : Element, selector : String) -> Element? raise SelectorError

    Return this element or its nearest matching ancestor.

    Element::closest_with

    source
    fn Element::closest_with(self : Element, selector : Selector) -> Element?

    Return this element or its nearest ancestor matching a precompiled selector.

    Element::document

    source
    fn Element::document(self : Element) -> Document

    Element::end

    source
    fn Element::end(self : Element) -> Int

    Element::equal

    source
    #deprecated("Use the Eq trait directly")
    fn Element::equal(self : Element, other : Element) -> Bool

    Element::find

    source
    fn Element::find(self : Element, selector : String) -> Element? raise SelectorError

    Element::find_with

    source
    fn Element::find_with(self : Element, selector : Selector) -> Element?

    Find the first descendant using a precompiled selector.

    Element::get_attr

    source
    fn Element::get_attr(self : Element, name : String) -> String?

    Read an attribute without distinguishing its ASCII letter case.

    Element::has_attr

    source
    fn Element::has_attr(self : Element, name : String) -> Bool

    Element::html

    source
    fn Element::html(self : Element) -> String

    The element's inner HTML exactly as written.

    Element::matches

    source
    fn Element::matches(self : Element, selector : String) -> Bool raise SelectorError

    Element::matches_with

    source
    fn Element::matches_with(self : Element, selector : Selector) -> Bool

    Match this element against a precompiled selector.

    Element::name

    source
    fn Element::name(self : Element) -> String

    Element::not_equal

    source
    #deprecated("Use the Eq trait directly")
    fn Element::not_equal(x : Element, y : Element) -> Bool

    Element::parent

    source
    fn Element::parent(self : Element) -> Parent

    Element::start

    source
    fn Element::start(self : Element) -> Int

    Element::stringify

    source
    fn Element::stringify(self : Element) -> String

    Element::text

    source
    fn Element::text(self : Element) -> String

    The decoded text of all descendant text nodes.

    Element::to_repr

    source
    #deprecated("Use the Debug trait directly")
    fn Element::to_repr(self : Element) -> 
    Repr

    Node

    source
    pub(all) enum Node {
      Element(Element)
      Text(Text)
      Comment(Comment)
      Directive(Directive)
    } derive(Eq, 
    Debug    )

    A child node in an HTML document.
    impl Stringify for Node

    Node::document

    source
    fn Node::document(self : Node) -> Document

    Node::end

    source
    fn Node::end(self : Node) -> Int

    Node::equal

    source
    #deprecated("Use derived trait implementations directly")
    fn Node::equal(Node, Node) -> Bool

    Node::not_equal

    source
    #deprecated("Use derived trait implementations directly")
    fn Node::not_equal(x : Node, y : Node) -> Bool

    Node::parent

    source
    fn Node::parent(self : Node) -> Parent

    Node::start

    source
    fn Node::start(self : Node) -> Int

    Node::stringify

    source
    fn Node::stringify(self : Node) -> String

    Node::to_repr

    source
    #deprecated("Use derived trait implementations directly")
    fn Node::to_repr(Node) -> 
    Repr

    Parent

    source
    pub(all) enum Parent {
      Document(Document)
      Element(Element)
    } derive(Eq, 
    Debug    )

    The parent of a top-level or nested node.

    Parent::equal

    source
    #deprecated("Use derived trait implementations directly")
    fn Parent::equal(Parent, Parent) -> Bool

    Parent::not_equal

    source
    #deprecated("Use derived trait implementations directly")
    fn Parent::not_equal(x : Parent, y : Parent) -> Bool

    Parent::to_repr

    source
    #deprecated("Use derived trait implementations directly")
    fn Parent::to_repr(Parent) -> 
    Repr

    Position

    source
    pub(all) struct Position {
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    A one-based line and column in the original UTF-16 source.

    Position::equal

    source
    #deprecated("Use derived trait implementations directly")
    fn Position::equal(Position, Position) -> Bool

    Position::not_equal

    source
    #deprecated("Use derived trait implementations directly")
    fn Position::not_equal(x : Position, y : Position) -> Bool

    Position::to_repr

    source
    #deprecated("Use derived trait implementations directly")
    fn Position::to_repr(Position) -> 
    Repr

    Selector

    source
    pub struct Selector {
      // private fields
    }

    A compiled CSS selector list.

    Selector::parse

    source
    fn Selector::parse(input : String) -> Selector raise SelectorError

    Compile a selector once for repeated matching.

    Text

    source
    pub struct Text {
      // private fields
    }

    A text node, including foreign-content CDATA sections.
    impl Stringify for Text
    impl Eq for Text
    impl Debug for Text

    Text::document

    source
    fn Text::document(self : Text) -> Document

    Text::end

    source
    fn Text::end(self : Text) -> Int

    Text::equal

    source
    #deprecated("Use the Eq trait directly")
    fn Text::equal(self : Text, other : Text) -> Bool

    Text::not_equal

    source
    #deprecated("Use the Eq trait directly")
    fn Text::not_equal(x : Text, y : Text) -> Bool

    Text::parent

    source
    fn Text::parent(self : Text) -> Parent

    Text::start

    source
    fn Text::start(self : Text) -> Int

    Text::stringify

    source
    fn Text::stringify(self : Text) -> String

    Text::to_repr

    source
    #deprecated("Use the Debug trait directly")
    fn Text::to_repr(self : Text) -> 
    Repr

    Text::value

    source
    fn Text::value(self : Text) -> String

    parse

    source
    fn parse(source : String) -> Document

    Parse HTML without raising on malformed markup. Recovery follows htmlparser2, not the WHATWG browser tree-construction algorithm.

    stringify

    source
    fn[T : Stringify] stringify(target : T) -> String

    Source Files