selectolax

https://selectolax.readthedocs.io/en/latest/
Admin
selectolax is a Python library for fast and efficient HTML parsing and element selection, leveraging...
Tokens:13,869
Snippets:133
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### traverse(include_text=False, skip_empty=False)

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Performs a depth-first traversal starting at the current node.

```APIDOC
## traverse(include_text=False, skip_empty=False)

### Description
Depth-first traversal starting at the current node.

### Parameters
- **include_text** (bool) - Optional - When True, include text nodes in the traversal sequence. Defaults to False.
- **skip_empty** (bool) - Optional - Skip text nodes that contain only ASCII whitespace when include_text is True. Defaults to False.

### Yields
- **LexborNode** - Nodes encountered in depth-first order beginning with the current node.
```

--------------------------------

### traverse(include_text=False)

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Iterates over all child and next nodes starting from the current level.

```APIDOC
## traverse(include_text=False)

### Description
Iterate over all child and next nodes starting from the current level.

### Parameters
- **include_text** (bool) - Optional - If True, includes text nodes as well.

### Yields
- **node** - The next node in the traversal.
```

--------------------------------

### inner_html

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Gets or sets the HTML representation of the child nodes, similar to innerHTML in JavaScript.

```APIDOC
## inner_html

### Description
Returns the HTML representation of the child nodes. Does not include the current node itself.
```

--------------------------------

### Parse HTML and Create Nodes with Lexbor

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Demonstrates initializing the Lexbor parser for full documents and fragments, and creating a new node.

```python
from selectolax.lexbor import LexborHTMLParser

html = """
<body>
    <span id="vspan"></span>
    <h1>Welcome to selectolax tutorial</h1>
    <div id="text">
        <p class='p3' style='display:none;'>Excepteur <i>sint</i> occaecat cupidatat non proident</p>
        <p class='p3' vid>Lorem ipsum</p>
    </div>
    <div>
        <p id='stext'>Lorem ipsum dolor sit amet, ea quo modus meliore platonem.</p>
    </div>
</body>
"""

fragment = """
<div>
    <p class="p3">
        Hello there!
    </p>
</div>
<script>
    document.querySelector(".p3").addEventListener("click", () => { ... });
</script>
"""

# Parse HTML as a full document
parser = LexborHTMLParser(html)

# Parse HTML as a fragment
frag_parser = LexborHTMLParser(html, is_fragment=True)

# Create a new node for  `parser`.
node = parser.create_node("div")
```

--------------------------------

### LexborHTMLParser.__init__

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Initializes a new LexborHTMLParser instance to parse raw HTML content.

```APIDOC
## LexborHTMLParser(html, is_fragment=False, fragment_tag='div', fragment_namespace='html')

### Description
Initializes the lexbor HTML parser with the provided HTML content.

### Parameters
- **html** (str | bytes) - Required - The raw HTML content to parse.
- **is_fragment** (bool) - Optional - Whether to parse as an HTML fragment.
- **fragment_tag** (str) - Optional - The tag name for the fragment root.
- **fragment_namespace** (str) - Optional - The namespace for the fragment.
```

--------------------------------

### Apply CSS attribute and pseudo-class selectors

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Demonstrates selecting elements using class, descendant, attribute, and pseudo-class selectors.

```python
html = """
<div>
    <article class="post published" data-id="1">
        <h2>First Post</h2>
        <p>Content of first post</p>
        <div class="meta">
            <span class="author">John</span>
            <span class="date">2023-01-01</span>
        </div>
    </article>
    <article class="post draft" data-id="2">
        <h2>Second Post</h2>
        <p>Content of second post</p>
        <div class="meta">
            <span class="author">Jane</span>
            <span class="date">2023-01-02</span>
        </div>
    </article>
    <aside class="sidebar">
        <div class="widget">
            <h3>Popular Posts</h3>
            <ul>
                <li><a href="#1">First Post</a></li>
                <li><a href="#2">Second Post</a></li>
            </ul>
        </div>
    </aside>
</div>
"""

parser = LexborHTMLParser(html)

# Attribute selectors
published_posts = parser.css('article.post.published')
print(f"Published posts: {len(published_posts)}")

# Descendant selectors
authors = parser.css('article .meta .author')
for author in authors:
    print(f"Author: {author.text()}")

# Pseudo-class selectors
first_article = parser.css('article:first-child')
if first_article:
    print(f"First article title: {first_article[0].css_first('h2').text()}")

# Attribute value selectors
specific_post = parser.css_first('article[data-id="1"]')
if specific_post:
    print(f"Post ID 1 title: {specific_post.css_first('h2').text()}")
```

--------------------------------

### css_first(query, default=None, strict=False)

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Evaluates a CSS selector and returns the first matching node.

```APIDOC
## css_first(query, default=None, strict=False)

### Description
Evaluate CSS selector against current node and its child nodes, returning the first match.

### Parameters
- **query** (str) - Required - The CSS selector query string.
- **default** (any) - Optional - Value to return if no match is found.
- **strict** (bool) - Optional - Whether to enforce strict matching.
```

--------------------------------

### HTMLParser

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Initializes an HTML parser instance to process raw HTML content.

```APIDOC
## HTMLParser(html, detect_encoding=True, use_meta_tags=True, decode_errors='ignore')

### Description
Initializes the HTML parser using the modest backend to parse raw HTML strings or bytes.

### Parameters
- **html** (str/bytes) - Required - The HTML content to parse.
- **detect_encoding** (bool) - Optional - Whether to automatically detect encoding if input is bytes. Default: True.
- **use_meta_tags** (bool) - Optional - Whether to use meta tags for encoding detection. Default: True.
- **decode_errors** (str) - Optional - Error handling strategy for decoding. Default: 'ignore'.
```

--------------------------------

### LexborHTMLParser.css_first

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Queries the HTML tree and returns the first matching element.

```APIDOC
## css_first(query, default=None, strict=False)

### Description
Returns the first element matching the CSS selector query.

### Parameters
- **query** (str) - Required - The CSS selector string.
- **default** (Any) - Optional - Value to return if no match is found.
- **strict** (bool) - Optional - If True, ensures exactly one match exists.
```

--------------------------------

### Create a new node with LexborHTMLParser

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Demonstrates how to create a new element node and append it to an existing element within the parsed HTML tree.

```python
>>> parser = LexborHTMLParser("<div></div>")
>>> new_node = parser.create_node("span")
>>> new_node.tag_name
'span'
>>> parser.css_first("div").append_child(new_node)
>>> parser.html
'<html><head></head><body><div><span></span></div></body></html>'
```

--------------------------------

### Select First Match

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Retrieve the first element matching a CSS selector.

```python
parser = LexborHTMLParser(html)

# Get first h1 element
print("H1: %s" % parser.css_first('h1').text())
```

--------------------------------

### Node.css_first

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Evaluates a CSS selector and returns the first matching node.

```APIDOC
## Node.css_first(query, default=None, strict=False)

### Description
Evaluate CSS selector against current node and its child nodes and return the first match.

### Parameters
- **query** (str) - Required - The CSS selector string.
- **default** (any) - Optional - Value to return if no match is found.
- **strict** (bool) - Optional - Whether to raise an error if no match is found.
```

--------------------------------

### select

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Selects nodes using a CSS selector.

```APIDOC
## select(query=None)

### Description
Select nodes given a CSS selector. Supports chained filtering.

### Parameters
- **query** (str or None) - Optional - The CSS selector to use.
```

--------------------------------

### Utility Functions

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Functions for creating tags, parsing fragments, and processing HTML strings.

```APIDOC
## selectolax.lexbor Functions

### create_tag(tag: str)
Creates a single empty node for a given HTML tag name.

### parse_fragment(html: str)
Parses HTML into a list of nodes without adding <html>, <head>, or <body> tags.

### extract_html_comment(text: str) -> str
Extracts the inner content of an HTML comment string, stripping surrounding whitespace.

### preprocess_input(html, decode_errors='ignore')
Preprocesses raw HTML input.
```

--------------------------------

### css_first

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Selects the first matching node from the HTML tree using a CSS selector.

```APIDOC
## css_first(query, default=None, strict=False)

### Description
Returns only the first match for the provided CSS selector.

### Parameters
- **query** (str) - Required - The CSS selector string.
- **default** (Any) - Optional - Value to return if no match is found. Default: None.
- **strict** (bool) - Optional - If True, raises an error if more than one match exists. Default: False.

### Returns
- **selector** (Node) - The first matching Node object.
```

--------------------------------

### css

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Selects nodes from the HTML tree using a CSS selector.

```APIDOC
## css(query)

### Description
Matches a CSS selector pattern against the HTML tree.

### Parameters
- **query** (str) - Required - The CSS selector string (e.g., "div > p").

### Returns
- **selector** (list) - A list of Node objects matching the query.
```

--------------------------------

### Extracting Form Data with Selectolax

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Uses LexborHTMLParser to navigate form elements and retrieve attributes and text content. Requires the selectolax library.

```python
form_html = """
<form id="contact-form" method="post" action="/submit">
    <div class="form-group">
        <label for="name">Name:</label>
        <input type="text" id="name" name="name" value="John Doe" required>
    </div>
    <div class="form-group">
        <label for="email">Email:</label>
        <input type="email" id="email" name="email" placeholder="john@example.com">
    </div>
    <div class="form-group">
        <label for="country">Country:</label>
        <select id="country" name="country">
            <option value="us">United States</option>
            <option value="ca" selected>Canada</option>
            <option value="uk">United Kingdom</option>
        </select>
    </div>
    <div class="form-group">
        <label>
            <input type="checkbox" name="newsletter" checked> Subscribe to newsletter
        </label>
    </div>
    <div class="form-group">
        <label for="message">Message:</label>
        <textarea id="message" name="message" rows="4">Hello there!</textarea>
    </div>
    <button type="submit">Submit</button>
</form>
"""

parser = LexborHTMLParser(form_html)

# Extract form metadata
form = parser.css_first('form')
print(f"Form ID: {form.attrs.get('id')}")
print(f"Form method: {form.attrs.get('method')}")
print(f"Form action: {form.attrs.get('action')}")

# Extract input fields
print("\nInput fields:")
for input_field in parser.css('input'):
    field_type = input_field.attrs.get('type', 'text')
    name = input_field.attrs.get('name')
    value = input_field.attrs.get('value', '')
    checked = 'checked' in input_field.attrs

    print(f"  {name} ({field_type}): {value} {'[checked]' if checked else ''}")

# Extract select options
print("\nSelect fields:")
for select in parser.css('select'):
    name = select.attrs.get('name')
    print(f"  {name}:")
    for option in select.css('option'):
        value = option.attrs.get('value')
        text = option.text()
        selected = 'selected' in option.attrs
        print(f"    {value}: {text} {'[selected]' if selected else ''}")

# Extract textarea
print("\nTextarea fields:")
for textarea in parser.css('textarea'):
    name = textarea.attrs.get('name')
    content = textarea.text()
    print(f"  {name}: {content}")
```

--------------------------------

### Use Lexbor-specific text content pseudo-classes

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Utilizes the :lexbor-contains pseudo-class for flexible case-sensitive or case-insensitive text matching.

```python
html = '<div><p>hello </p><p id="main">lexbor is AwesOme</p></div>'
parser = LexborHTMLParser(html)

# Case-insensitive search
results_ci = parser.css('p:lexbor-contains("awesome" i)')
print(f"Case-insensitive results: {len(results_ci)}")

# Case-sensitive search
results_cs = parser.css('p:lexbor-contains("AwesOme")')
print(f"Case-sensitive results: {len(results_cs)}")
print(f"Matching text: {results_cs[0].text()}")
```

--------------------------------

### LexborHTMLParser.create_node

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Creates a new empty HTML element node.

```APIDOC
## create_node(tag)

### Description
Creates a single empty node for the specified HTML tag name.

### Parameters
- **tag** (str) - Required - The name of the tag to create (e.g., 'div').

### Returns
- **LexborNode** - The newly created element node.
```

--------------------------------

### LexborNode.css_first

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Evaluate CSS selector against current node and return the first match.

```APIDOC
## css_first(query, default=None, strict=False)

### Description
Same as css but returns only the first match. When strict=False stops at the first match.

### Parameters
- **query** (str) - Required
- **default** (Any) - Optional - Default value to return if there is no match.
- **strict** (bool) - Optional - Set to True if you want to check if there is strictly only one match in the document.

### Returns
- **selector** (LexborNode) - LexborNode object
```

--------------------------------

### Insert a child node

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Demonstrates inserting a node from one parser into another using insert_child.

```python
>>> html_parser = LexborHTMLParser('<div>Get <span alt="Laptop"> <div>Laptop</div> </span></div>')
>>> html_parser2 = LexborHTMLParser('<div>Test</div>')
>>> span_node = html_parser.css_first('span')
>>> span_node.insert_child(html_parser2.body.child)
<div>Get <span alt="Laptop"> <div>Laptop</div> <div>Test</div> </span></div>'
```

--------------------------------

### LexborHTMLParser.css

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Queries the HTML tree using CSS selectors.

```APIDOC
## css(query)

### Description
Matches the provided CSS selector query against the HTML tree.

### Parameters
- **query** (str) - Required - The CSS selector string to evaluate.

### Returns
- **list** - A list of matching Node objects.
```

--------------------------------

### tags

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Returns all tags that match the provided name.

```APIDOC
## tags(name)

### Description
Return all tags that match the provided name.

### Parameters
- **name** (str) - Required - Tag name to search for.
```

--------------------------------

### html_pretty

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Returns a pretty-printed HTML string for the current node with configurable formatting options.

```APIDOC
## html_pretty(indent=0, skip_ws_nodes=False, skip_comment=False, raw=False, without_closing=False, tag_with_ns=False, without_text_indent=False, full_doctype=False, html5test=False)

### Description
Returns pretty-printed HTML for the current node.

### Parameters
- **indent** (int) - Optional - Initial indentation level. Defaults to 0.
- **skip_ws_nodes** (bool) - Optional - Skip text nodes that contain only whitespace.
- **skip_comment** (bool) - Optional - Exclude HTML comment nodes.
- **raw** (bool) - Optional - Serialize text and attribute values without HTML escaping.
- **without_closing** (bool) - Optional - Omit closing tags for non-void elements.
- **tag_with_ns** (bool) - Optional - Include namespace prefixes in tag names.
- **without_text_indent** (bool) - Optional - Disable extra indentation around text and comment content.
- **full_doctype** (bool) - Optional - Serialize full document type declaration.
- **html5test** (bool) - Optional - Use Lexbor’s HTML5 test formatting mode.
```

--------------------------------

### LexborHTMLParser.html_pretty

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Returns a formatted, human-readable HTML string representation of the document.

```APIDOC
## html_pretty(indent=0, skip_ws_nodes=False, skip_comment=False, raw=False, without_closing=False, tag_with_ns=False, without_text_indent=False, full_doctype=False, html5test=False)

### Description
Serializes the document tree into a pretty-printed HTML string.

### Parameters
- **indent** (int) - Optional - Initial indentation level.
- **skip_ws_nodes** (bool) - Optional - Exclude whitespace-only text nodes.
- **skip_comment** (bool) - Optional - Exclude comment nodes.
- **raw** (bool) - Optional - Serialize without HTML escaping.
```

--------------------------------

### Insert a node before another node

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Demonstrates inserting text or a node before a target element using insert_before.

```python
>>> tree = LexborHTMLParser('<div>Get <img src="" alt="Laptop"></div>')
>>> img = tree.css_first('img')
>>> img.insert_before(img.attributes.get('alt', ''))
>>> tree.body.child.html
'<div>Get Laptop<img src="" alt="Laptop"></div>'
```

```python
>>> html_parser = LexborHTMLParser('<div>Get <span alt="Laptop"><img src="/jpg"> <div></div></span></div>')
>>> html_parser2 = LexborHTMLParser('<div>Test</div>')
>>> img_node = html_parser.css_first('img')
>>> img_node.insert_before(html_parser2.body.child)
<div>Get <span alt="Laptop"><div>Test</div><img src="/jpg"> <div></div></span></div>'
```

--------------------------------

### LexborNode.html_pretty

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Return pretty-printed HTML for the current node.

```APIDOC
## html_pretty(indent=0, skip_ws_nodes=False, skip_comment=False, raw=False, without_closing=False, tag_with_ns=False, without_text_indent=False, full_doctype=False, html5test=False)

### Description
Return pretty-printed HTML for the current node.

### Parameters
- **indent** (int) - Optional - Initial indentation level.
- **skip_ws_nodes** (bool) - Optional - Skip text nodes that contain only whitespace.
- **skip_comment** (bool) - Optional - Exclude HTML comment nodes.
- **raw** (bool) - Optional - Serialize without HTML escaping.
- **without_closing** (bool) - Optional - Omit closing tags for non-void elements.
- **tag_with_ns** (bool) - Optional - Include namespace prefixes.
- **without_text_indent** (bool) - Optional - Disable extra indentation around text/comment content.

### Returns
- **text** (str)
```

--------------------------------

### Default Return Values

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Provide a fallback value when a CSS selector finds no matches.

```python
# Return default value if no matches found
print("Title: %s" % parser.css_first('title', default='not-found'))
```

--------------------------------

### any_css_matches(selectors)

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Checks if any of the provided CSS selectors match the current node.

```APIDOC
## any_css_matches(selectors)

### Description
Returns True if any of the provided CSS selectors match the current node.

### Parameters
- **selectors** (tuple) - Required - A tuple of CSS selector strings.
```

--------------------------------

### Extract Structured Data from HTML Tables

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Shows how to iterate through table rows and map cell data to headers.

```python
table_html = """
<table class="data-table">
    <thead>
        <tr>
            <th>Name</th>
            <th>Age</th>
            <th>City</th>
            <th>Occupation</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Alice Johnson</td>
            <td>28</td>
            <td>New York</td>
            <td>Software Engineer</td>
        </tr>
        <tr>
            <td>Bob Smith</td>
            <td>35</td>
            <td>Los Angeles</td>
            <td>Designer</td>
        </tr>
        <tr>
            <td>Carol Brown</td>
            <td>42</td>
            <td>Chicago</td>
            <td>Manager</td>
        </tr>
    </tbody>
</table>
"""

parser = LexborHTMLParser(table_html)

# Extract headers
headers = [th.text() for th in parser.css('thead th')]
print("Headers:", headers)

# Extract data rows
rows = []
for tr in parser.css('tbody tr'):
    row_data = [td.text() for td in tr.css('td')]
    rows.append(row_data)

# Display as structured data
for i, row in enumerate(rows):
    print(f"\nRow {i+1}:")
    for header, value in zip(headers, row):
        print(f"  {header}: {value}")
```

--------------------------------

### CSS Chaining

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Filter elements by chaining multiple CSS selectors.

```python
html = """
<div id="container">
    <span class="red"></span>
    <span class="green"></span>
    <span class="red"></span>
    <span class="green"></span>
</div>
"""

parser = LexborHTMLParser(html)

# Chain selectors: start with div, then span, then .red
red_spans = parser.select('div').css("span").css(".red").matches
print([node.html for node in red_spans])
```

--------------------------------

### LexborNode.select

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Selects nodes using a CSS selector.

```APIDOC
## LexborNode.select(query=None)

### Description
Select nodes given a CSS selector. Supports chained filtering.

### Parameters
- **query** (str or None) - Optional - The CSS selector to use when searching for nodes.
```

--------------------------------

### Node.css

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Evaluates a CSS selector against the current node and its child nodes.

```APIDOC
## Node.css(query)

### Description
Evaluate CSS selector against current node and its child nodes.

### Parameters
- **query** (str) - Required - The CSS selector string.
```

--------------------------------

### text

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Returns the text content of the node.

```APIDOC
## text(deep=True, separator='', strip=False, skip_empty=False)

### Description
Returns the text of the node including text of all its child nodes.

### Parameters
- **deep** (bool) - Optional - If True, includes text from all child nodes.
- **separator** (str) - Optional - Separator to use when joining text.
- **strip** (bool) - Optional - If true, calls str.strip() on each text part.
- **skip_empty** (bool) - Optional - Exclude text nodes whose content is only whitespace.
```

--------------------------------

### Select All Elements with CSS

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Iterate through all nodes matching a specific CSS selector and access their properties.

```python
from selectolax.lexbor import LexborHTMLParser

html = """
<body>
    <div id="text">
        <p class='p3' style='display:none;'>Excepteur <i>sint</i> occaecat cupidatat non proident</p>
        <p class='p3' vid>Lorem ipsum</p>
    </div>
    <div>
        <p id='stext'>Lorem ipsum dolor sit amet, ea quo modus meliore platonem.</p>
    </div>
</body>
"""

parser = LexborHTMLParser(html)
selector = "p.p3"

for node in parser.css(selector):
    print('---------------------')
    print('Node: %s' % node.html)
    print('attributes: %s' % node.attributes)
    print('node text: %s' % node.text(deep=True, separator='', strip=False))
    print('tag: %s' % node.tag)
    print('parent tag: %s' % node.parent.tag)
    if node.last_child:
        print('last child inside current node: %s' % node.last_child.html)
    print('---------------------\n')
```

--------------------------------

### Navigate Sibling Elements with LexborHTMLParser

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Demonstrates accessing adjacent sibling nodes in the DOM. Note that text nodes like whitespace may require traversing multiple steps.

```python
html = """
<nav>
    <a href="/">Home</a>
    <a href="/about">About</a>
    <a href="/contact" class="active">Contact</a>
    <a href="/blog">Blog</a>
</nav>
"""

parser = LexborHTMLParser(html)
active_link = parser.css_first("a.active")

if active_link:
    print(f"Active link: {active_link.text()}")
    # We need to call it twice, because there are text nodes (spaces and new lines) between <a> elements
    if active_link.prev:
        print(f"Previous link: {active_link.prev.prev.text()}")

    if active_link.next:
        print(f"Next link: {active_link.next.next.text()}")
```

--------------------------------

### Retrieve HTML content

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Access inner and outer HTML of a node using the .inner_html and .html properties.

```python
from selectolax.lexbor import LexborHTMLParser
html = """
<div id="main">
  <div>Hi there</div>
  <div id="updated">2021-08-15</div>
 </div>
"""
parser = LexborHTMLParser(html)
node = parser.css_first("#main")
print("Inner html:\n")
print(node.inner_html)
print("\nOuter html:\n")
print(node.html)
```

--------------------------------

### LexborNode.replace_with

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Replaces the current node with a new value.

```APIDOC
## LexborNode.replace_with(value)

### Description
Replace current Node with specified value (text, bytes, or Node).

### Parameters
- **value** (str, bytes, or Node) - Required - The text or Node instance to replace the current node with.
```

--------------------------------

### LexborSelector

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

The LexborSelector class provides advanced CSS selection tools that mimic XPath-like features for filtering and querying nodes.

```APIDOC
## LexborSelector

### Description
An advanced CSS selector toolkit that supports additional operations beyond standard CSS queries, including attribute length filtering and text content searching.

### Methods
- **any_attribute_longer_than(attribute: str, length: int, start: str = None) -> bool**: Returns True if any attribute matches the length criteria.
- **any_matches**: Property returning True if any nodes match the current selector.
- **any_text_contains(text: str, deep: bool = True, separator: str = '', strip: bool = False) -> bool**: Returns True if any node in the scope contains the specified text.
- **attribute_longer_than(attribute: str, length: int, start: str = None) -> LexborSelector**: Filters current matches by attribute length.
- **css(query: str)**: Evaluates a CSS selector against the current scope.
- **matches**: Property returning a list of all possible matches.
- **text_contains(text: str, deep: bool = True, separator: str = '', strip: bool = False) -> LexborSelector**: Filters current matches based on text content.
```

--------------------------------

### Node.insert_before

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Inserts a node or text before the current node.

```APIDOC
## Node.insert_before(value)

### Description
Insert a node or text before the current Node.

### Parameters
- **value** (str, bytes, or Node) - Required - The text or Node instance to insert.
```

--------------------------------

### Replace Node Content

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Demonstrates replacing a specific node within an HTML tree using LexborHTMLParser.

```python
>>> html_parser = LexborHTMLParser('<div>Get <span alt="Laptop"><img src="/jpg"> <div></div></span></div>')
>>> html_parser2 = LexborHTMLParser('<div>Test</div>')
>>> img_node = html_parser.css_first('img')
>>> img_node.replace_with(html_parser2.body.child)
'<div>Get <span alt="Laptop"><div>Test</div> <div></div></span></div>'
```

--------------------------------

### Insert a node after another node

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Demonstrates inserting text or a node after a target element using insert_after.

```python
>>> tree = LexborHTMLParser('<div>Get <img src="" alt="Laptop"></div>')
>>> img = tree.css_first('img')
>>> img.insert_after(img.attributes.get('alt', ''))
>>> tree.body.child.html
'<div>Get <img src="" alt="Laptop">Laptop</div>'
```

```python
>>> html_parser = LexborHTMLParser('<div>Get <span alt="Laptop"><img src="/jpg"> <div></div></span></div>')
>>> html_parser2 = LexborHTMLParser('<div>Test</div>')
>>> img_node = html_parser.css_first('img')
>>> img_node.insert_after(html_parser2.body.child)
<div>Get <span alt="Laptop"><img src="/jpg"><div>Test</div> <div></div></span></div>'
```

--------------------------------

### Extract Links and Images

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Iterates through CSS selectors to extract attributes like href from links and src from images.

```python
html = '''
<div>
    <a href="https://example.com">Link 1</a>
    <a href="/page2">Link 2</a>
    <img src="image1.jpg" alt="Image 1">
    <img src="image2.png" alt="Image 2">
</div>
'''

parser = LexborHTMLParser(html)

# Extract all links
for link in parser.css('a[href]'):
    print(f"Link: {link.text()} -> {link.attrs['href']}")

# Extract all images
for img in parser.css('img[src]'):
    print(f"Image: {img.attrs.get('alt', 'No alt')} -> {img.attrs['src']}")
```

--------------------------------

### unwrap(delete_empty=False)

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Replaces the current node with its children, effectively removing the tag.

```APIDOC
## unwrap(delete_empty=False)

### Description
Replace node with whatever is inside this node.

### Parameters
- **delete_empty** (bool) - Optional - Whether to delete empty tags. Default: False.
```

--------------------------------

### LexborNode.insert_before

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Inserts a node or text string before the current node.

```APIDOC
## Method: insert_before

### Description
Insert a node before the current Node. When a text string is passed, it is treated as text and HTML tags are escaped.

### Parameters
- **value** (str, bytes, or Node) - The text or Node instance to insert before the Node.
```

--------------------------------

### Insert nodes into DOM

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Insert text, HTML subtrees, or new nodes before, after, or as children of existing elements.

```python
html = """
<div id="container">
    <span class="red"></span>
    <span class="green"></span>
    <span class="red"></span>
    <span class="green"></span>
</div>
"""

parser = LexborHTMLParser(html)

# Insert text before an element
red_node = parser.css_first('.red')
red_node.insert_before("Hello")

# Insert HTML nodes
subtree = LexborHTMLParser("<div>Hi</div>")
green_node = parser.css_first('.green')
green_node.insert_before(subtree)

# Insert before, after, or as child
car_div = parser.create_node("div")
car_div.inner_html = "Car"
green_node.insert_before(car_div)
green_node.insert_after(car_div)
green_node.insert_child(car_div)

print(parser.body.html)
```

--------------------------------

### LexborNode.css

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Evaluate CSS selector against current node and its child nodes.

```APIDOC
## css(query)

### Description
Evaluate CSS selector against current node and its child nodes. Matches pattern query against HTML tree.

### Parameters
- **query** (str) - Required - CSS selector (e.g. “div > :nth-child(2n+1):not(:has(a))”).

### Returns
- **selector** (list) - List of Node objects
```

--------------------------------

### Insert text before a node

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Inserts a string as text before the specified node. HTML tags in the string will be escaped.

```python
>>> tree = LexborHTMLParser('<div>Get <img src="" alt="Laptop"></div>')
>>> img = tree.css_first('img')
>>> img.insert_before(img.attributes.get('alt', ''))
>>> tree.body.child.html
'<div>Get Laptop<img src="" alt="Laptop"></div>'
```

--------------------------------

### Traverse DOM Tree

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Walks through every node in the DOM tree to extract text content or identify tags.

```python
parser = LexborHTMLParser(html)

# Traverse the entire tree
for node in parser.root.traverse(include_text=True):
    if node.tag == '-text':
        text = node.text(deep=True).strip()
        if text:
            print(text)
    else:
        print(node.tag)
```

--------------------------------

### Access node attributes

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Retrieves all attributes of a node as a dictionary.

```python
>>> tree = HTMLParser("<div data id='my_id'></div>")
>>> node = tree.css_first('div')
>>> node.attributes
{'data': None, 'id': 'my_id'}
```

--------------------------------

### text(self, deep=True, separator='', strip=False, skip_empty=False)

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Returns the text content of the node, optionally including child nodes and applying formatting.

```APIDOC
## text(self, deep=True, separator='', strip=False, skip_empty=False)

### Description
Returns the text of the node including text of all its child nodes.

### Parameters
- **deep** (bool) - Optional - If True, includes text from all child nodes. Defaults to True.
- **separator** (str) - Optional - The separator to use when joining text from different nodes. Defaults to ''.
- **strip** (bool) - Optional - If true, calls str.strip() on each text part to remove extra white spaces. Defaults to False.
- **skip_empty** (bool) - Optional - Exclude text nodes whose content is only ASCII whitespace. Defaults to False.

### Returns
- **text** (str) - Combined textual content assembled according to the provided options.
```

--------------------------------

### Node.insert_after

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Inserts a node or text after the current node.

```APIDOC
## Node.insert_after(value)

### Description
Insert a node or text after the current Node.

### Parameters
- **value** (str, bytes, or Node) - Required - The text or Node instance to insert.
```

--------------------------------

### LexborNode.inner_html_pretty

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Returns a pretty-printed HTML representation of the child nodes with configurable formatting options.

```APIDOC
## Method: inner_html_pretty

### Description
Return pretty-printed HTML representation of the child nodes.

### Parameters
- **indent** (int, optional) - Initial indentation level. Defaults to 0.
- **skip_ws_nodes** (bool, optional) - Skip text nodes that contain only whitespace.
- **skip_comment** (bool, optional) - Exclude HTML comment nodes.
- **raw** (bool, optional) - Serialize text and attribute values without HTML escaping.
- **without_closing** (bool, optional) - Omit closing tags for non-void elements.
- **tag_with_ns** (bool, optional) - Include namespace prefixes in serialized tag names.
- **without_text_indent** (bool, optional) - Disable extra indentation around text and comment content.
- **full_doctype** (bool, optional) - Serialize the full document type declaration.
- **html5test** (bool, optional) - Serialize using Lexbor’s HTML5 test formatting mode.
```

--------------------------------

### text(deep=True, separator='', strip=False, skip_empty=False)

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Returns concatenated text from the node, with options to control depth, separators, and whitespace handling.

```APIDOC
## text(deep=True, separator='', strip=False, skip_empty=False)

### Description
Returns concatenated text from this node.

### Parameters
- **deep** (bool) - Optional - When True (default), include text from all descendant nodes; when False, only include direct children.
- **separator** (str) - Optional - String inserted between successive text fragments.
- **strip** (bool) - Optional - If True, apply str.strip() to each fragment before joining. Defaults to False.
- **skip_empty** (bool) - Optional - Exclude text nodes whose content is only ASCII whitespace when True. Defaults to False.

### Returns
- **text** (str) - Combined textual content assembled according to the provided options.
```

--------------------------------

### LexborNode.iter

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Iterates over the direct children of the node.

```APIDOC
## LexborNode.iter(include_text=False, skip_empty=False)

### Description
Iterates over direct children of this node.

### Parameters
- **include_text** (bool) - Optional - When True, yield text nodes in addition to element nodes. Defaults to False.
- **skip_empty** (bool) - Optional - When include_text is True, ignore text nodes made up solely of ASCII whitespace. Defaults to False.
```

--------------------------------

### Insert content before a node

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Inserts text or a Node object before the current node.

```python
>>> tree = HTMLParser('<div>Get <img src="" alt="Laptop"></div>')
>>> img = tree.css_first('img')
>>> img.insert_before(img.attributes.get('alt', ''))
>>> tree.body.child.html
'<div>Get Laptop<img src="" alt="Laptop"></div>'
```

```python
>>> html_parser = HTMLParser('<div>Get <span alt="Laptop"><img src="/jpg"> <div></div></span></div>')
>>> html_parser2 = HTMLParser('<div>Test</div>')
>>> img_node = html_parser.css_first('img')
>>> img_node.insert_before(html_parser2.body.child)
<div>Get <span alt="Laptop"><div>Test</div><img src="/jpg"> <div></div></span></div>'
```

--------------------------------

### Unwrap a node

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Replaces a node with its inner content. By default, empty tags are ignored unless delete_empty is set to True.

```python
>>>  tree = HTMLParser("<div>Hello <i>world</i>!</div>")
>>>  tree.css_first('i').unwrap()
>>>  tree.html
'<html><head></head><body><div>Hello world!</div></body></html>'
```

--------------------------------

### Strict Mode

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Enforce a single match requirement, raising an error if multiple matches are found.

```python
# This will raise an error if multiple matches are found
try:
    result = parser.css_first("p.p3", default='not-found', strict=True)
except Exception as e:
    print(f"Error: {e}")
```

--------------------------------

### Chain nested selectors

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Find deeply nested elements by chaining .css_first() calls.

```python
# Chain CSS selectors
result = parser.css_first('div#text').css_first('p:nth-child(2)').html
print(result)
```

--------------------------------

### Replace node with content

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Replaces a node with either a string or another node object.

```python
>>> tree = LexborHTMLParser('<div>Get <img src="" alt="Laptop"></div>')
>>> img = tree.css_first('img')
>>> img.replace_with(img.attributes.get('alt', ''))
>>> tree.body.child.html
'<div>Get Laptop</div>'
```

```python
>>> html_parser = LexborHTMLParser('<div>Get <span alt="Laptop"><img src="/jpg"> <div></div></span></div>')
>>> html_parser2 = LexborHTMLParser('<div>Test</div>')
>>> img_node = html_parser.css_first('img')
>>> img_node.replace_with(html_parser2.body.child)
'<div>Get <span alt="Laptop"><div>Test</div> <div></div></span></div>'
```

--------------------------------

### unwrap_tags(tags, delete_empty=False)

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Unwraps specified tags from the HTML tree.

```APIDOC
## unwrap_tags(tags, delete_empty=False)

### Description
Unwraps specified tags from the HTML tree. Works the same as the unwrap method, but applied to a list of tags.

### Parameters
- **tags** (list) - Required - List of tags to remove.
- **delete_empty** (bool) - Optional - Whether to delete empty tags. Default: False.
```

--------------------------------

### inner_html_pretty

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Returns a pretty-printed HTML representation of the child nodes.

```APIDOC
## inner_html_pretty(indent=0, skip_ws_nodes=False, skip_comment=False, raw=False, without_closing=False, tag_with_ns=False, without_text_indent=False, full_doctype=False, html5test=False)

### Description
Return pretty-printed HTML representation of the child nodes.

### Parameters
- **indent** (int) - Optional - Initial indentation level. Defaults to 0.
- **skip_ws_nodes** (bool) - Optional - Skip text nodes that contain only whitespace.
- **skip_comment** (bool) - Optional - Exclude HTML comment nodes.
- **raw** (bool) - Optional - Serialize without HTML escaping.
- **without_closing** (bool) - Optional - Omit closing tags for non-void elements.
- **tag_with_ns** (bool) - Optional - Include namespace prefixes.
- **without_text_indent** (bool) - Optional - Disable extra indentation around text/comments.
- **full_doctype** (bool) - Optional - Serialize full doctype declaration.
- **html5test** (bool) - Optional - Use HTML5 test formatting mode.
```

--------------------------------

### LexborNode.insert_after

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Inserts a node or text string after the current node.

```APIDOC
## Method: insert_after

### Description
Insert a node after the current Node. When a text string is passed, it is treated as text and HTML tags are escaped.

### Parameters
- **value** (str, bytes, or Node) - The text or Node instance to insert after the Node.
```

--------------------------------

### text

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Extracts text content from the node and its children.

```APIDOC
## text(deep=True, separator='', strip=False)

### Description
Returns the text content of the node, optionally including children.

### Parameters
- **deep** (bool) - Optional - If True, includes text from all child nodes. Default: True.
- **separator** (str) - Optional - String used to join text from different nodes. Default: ''.
- **strip** (bool) - Optional - If True, removes extra whitespace from text parts. Default: False.

### Returns
- **text** (str) - The extracted text content.
```

--------------------------------

### Insert a child node

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Demonstrates appending a text node to the end of a parent element using insert_child.

```python
>>> tree = LexborHTMLParser('<div>Get <img src=""></div>')
>>> div = tree.css_first('div')
>>> div.insert_child('Laptop')
>>> tree.body.child.html
'<div>Get <img src="">Laptop</div>'
```

--------------------------------

### LexborHTMLParser

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

The primary class for parsing raw HTML strings or bytes. It provides methods to query the document tree using CSS selectors and manipulate nodes.

```APIDOC
## LexborHTMLParser(html, is_fragment=False, fragment_tag='div', fragment_namespace='html')

### Description
Initializes the Lexbor HTML parser with the provided HTML content.

### Parameters
- **html** (str | bytes) - Required - The raw HTML content to parse.
- **is_fragment** (bool) - Optional - Whether to parse as an HTML fragment.
- **fragment_tag** (str) - Optional - The tag to use for fragment parsing.
- **fragment_namespace** (str) - Optional - The namespace for fragment parsing.
```

--------------------------------

### text(deep=True, separator='', strip=False)

Source: https://selectolax.readthedocs.io/en/latest/parser.html

Returns the text of the node, optionally including child nodes with custom separators and whitespace stripping.

```APIDOC
## text(deep=True, separator='', strip=False)

### Description
Returns the text of the node including text of all its child nodes.

### Parameters
- **deep** (bool) - Optional - If True, includes text from all child nodes. Default: True.
- **separator** (str) - Optional - The separator to use when joining text from different nodes. Default: ''.
- **strip** (bool) - Optional - If true, calls str.strip() on each text part to remove extra white spaces. Default: False.

### Returns
- **text** (str) - The extracted text content.
```

--------------------------------

### Extract Text Content

Source: https://selectolax.readthedocs.io/en/latest/examples.html

Retrieves text from HTML elements using various formatting options like custom separators and whitespace control.

```python
parser = LexborHTMLParser('<div><p>Hello <b>world</b>!</p></div>')

# Get text content with different options
node = parser.css_first('p')

# Get all text content
print(node.text())  # "Hello world!"

# Get text with custom separator
print(node.text(separator=' | '))  # "Hello | world | !"

# Get text without stripping whitespace
print(node.text(strip=False))
```

--------------------------------

### Insert text after a node

Source: https://selectolax.readthedocs.io/en/latest/selectolax.html

Inserts a string as text after the specified node. HTML tags in the string will be escaped.

```python
>>> tree = LexborHTMLParser('<div>Get <img src="" alt="Laptop"></div>')
>>> img = tree.css_first('img')
>>> img.insert_after(img.attributes.get('alt', ''))
>>> tree.body.child.html
'<div>Get <img src="" alt="Laptop">Laptop</div>'
```

--------------------------------

### Unwrap a node

Source: https://selectolax.readthedocs.io/en/latest/lexbor.html

Replaces a node with its inner content using the unwrap method.

```python
>>>  tree = LexborHTMLParser("<div>Hello <i>world</i>!</div>")
>>>  tree.css_first('i').unwrap()
>>>  tree.html
'<html><head></head><body><div>Hello world!</div></body></html>'
```
Tokens:
Raw