### CSS-like Selector Syntax Reference

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Reference for special attribute selectors used to match HTML elements based on attribute values. Includes selectors for attributes that start with, end with, or contain a specific value. Note: The source text uses '[attribute$=value]' for both 'starts with' and 'ends with' descriptions, which may be a typo for 'starts with' (typically '^=' in standard CSS).

```APIDOC
[attribute$=value]
  Description: Matches elements that have the specified attribute and it starts with a certain value.
```

```APIDOC
[attribute$=value]
  Description: Matches elements that have the specified attribute and it ends with a certain value.
```

```APIDOC
[attribute*=value]
  Description: Matches elements that have the specified attribute and it contains a certain value.
```

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

### Iterating and Accessing Specific Elements

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Examples of iterating through selected elements using foreach and directly accessing specific elements by index using find().

```PHP
// Find all <li> in <ul>
foreach($html->find('ul') as $ul)
{
		 foreach($ul->find('li') as $li)
		 {
				 // do something...
		 }
}
```

```PHP
// Find first <li> in first <ul>
$e = $html->find('ul', 0)->find('li', 0);
```

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

### PHP Simple HTML DOM Parser: Fetching Content with cURL

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_faq.htm

This example provides a workaround for fetching web page content when the `allow_url_fopen` setting is disabled on the server, which is common for security reasons. It uses the cURL library to retrieve the HTML content, which is then passed to `str_get_html()` for DOM object creation.

```PHP
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, 'http://????????');
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl, CURLOPT_CONNECTTIMEOUT, 10);
$str = curl_exec($curl);
curl_close($curl);

$html= str_get_html($str);
// ...
```

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

### PHP: Scraping Articles from a Website

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP example demonstrates a more complex scraping scenario. It loads content from a news website, finds all article blocks using a CSS selector (`div.article`), and then extracts specific details like title, intro, and details from each article using nested `find()` calls. The extracted data is stored in an array.

```php
// Create DOM from URL
$html = file_get_html('http://slashdot.org/');
  
// Find all article blocks
foreach($html->find('div.article') as $article) {
    $item['title']    = $article->find('div.title', 0)->plaintext;
    $item['intro']    = $article->find('div.intro', 0)->plaintext;
    $item['details']  = $article->find('div.details', 0)->plaintext;
    $articles[] = $item;
}
  
print_r($articles);
```

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

### Customizing Parsing Behavior with Callbacks

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Shows how to define a callback function that can modify elements during the parsing process, exemplified by hiding all <b> tags. The example for registering the callback is incomplete in the source text.

```PHP
// Write a function with parameter "$element"
function my_callback($element) {
		// Hide all <b> tags
		if ($element->tag=='b')
				$element->outertext = '';
}
```

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

### PHP: Get HTML Elements from URL or File

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP snippet demonstrates how to load HTML content from a URL or local file using `file_get_html()` and then find specific elements like images and links using the `find()` method. It iterates through found elements to extract their `src` and `href` attributes.

```php
// Create DOM from URL or file
$html = file_get_html('http://www.google.com/');
  
// Find all images
foreach($html->find('img') as $element)
      echo $element->src . '<br>';
  
// Find all links
foreach($html->find('a') as $element)
      echo $element->href . '<br>';
```

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

### Dumping HTML DOM Contents

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Demonstrates methods to convert the internal DOM tree back into an HTML string or save it directly to a file. Also shows a quick way to get the string representation by casting the object.

```PHP
// Dumps the internal DOM tree back into string
$str = $html->save();
```

```PHP
// Dumps the internal DOM tree back into a file
$html->save('result.htm');
```

```PHP
// Dumps the internal DOM tree back into string
$str = $html;
```

```PHP
// Print it!
echo $html;
```

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

### Modifying HTML Element Content and Structure

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Examples demonstrating how to extract plain text from the entire HTML document, wrap an element with new HTML, remove an element, and append or insert new HTML content relative to an existing element.

```PHP
// Extract contents from HTML
echo $html->plaintext;
```

```PHP
// Wrap a element
$e->outertext = '<div class="wrap">' . $e->outertext . '<div>';
```

```PHP
// Remove a element, set it's outertext as an empty string
$e->outertext = '';
```

```PHP
// Append a element
$e->outertext = $e->outertext . '<div>foo<div>';
```

```PHP
// Insert a element
$e->outertext = '<div>foo<div>' . $e->outertext;
```

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

### Get, Set, and Remove HTML Element Attributes

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Illustrates how to programmatically get, set, remove, and check for the existence of attributes on an HTML element object. Handles non-value attributes like 'checked' or 'selected'.

```PHP
// Get a attribute ( If the attribute is non-value attribute (eg. checked, selected...), it will returns true or false)
$value = $e->href;
```

```PHP
// Set a attribute(If the attribute is non-value attribute (eg. checked, selected...), set it's value as true or false)
$e->href = 'my link';
```

```PHP
// Remove a attribute, set it's value as null!
$e->href = null;
```

```PHP
// Determine whether a attribute exist?
if(isset($e->href))
			echo 'href exist!';
```

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

### APIDOC: Simple HTML DOM Attribute Selectors

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This section documents the attribute selector operators supported by the Simple HTML DOM Parser's `find()` method. It lists various filters for matching elements based on the presence, absence, exact value, or starting value of their attributes.

```APIDOC
Filter            Description
[attribute]       Matches elements that have the specified attribute.
[!attribute]      Matches elements that don't have the specified attribute.
[attribute=value] Matches elements that have the specified attribute with a certain value.
[attribute!=value] Matches elements that don't have the specified attribute with a certain value.
[attribute^=value]
```

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

### PHP: Extract Plaintext from HTML Document

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP snippet illustrates how to quickly extract all plaintext content from an HTML document loaded from a URL. It uses `file_get_html()` to load the content and then accesses the `plaintext` property of the DOM object to get the text without any HTML tags.

```php
// Dump contents (without tags) from HTML
echo file_get_html('http://www.google.com/')->plaintext;
```

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

### PHP: Modify HTML Elements from String

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP example shows how to create a DOM object from an HTML string using `str_get_html()`. It then demonstrates modifying element attributes (like `class`) and inner text using the `find()` method and direct property assignment, finally echoing the modified HTML.

```php
// Create DOM from string
$html = str_get_html('<div id="hello">Hello</div><div id="world">World</div>');
  
$html->find('div', 1)->class = 'bar';
  
$html->find('div[id=hello]', 0)->innertext = 'foo';
  
echo $html; // Output: <div id="hello">foo</div><div id="world" class="bar">World</div>
```

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

### PHP: Create DOM Object (Quick Way)

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP snippet shows the quick and convenient ways to create a Simple HTML DOM object. It demonstrates loading HTML from a string, a URL, or a local HTML file using the `str_get_html()` and `file_get_html()` functions.

```php
// Create a DOM object from a string
$html = str_get_html('<html><body>Hello!</body></html>');
  
// Create a DOM object from a URL
$html = file_get_html('http://www.google.com/');
  
// Create a DOM object from a HTML file
$html = file_get_html('test.htm');
```

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

### Navigating the DOM Tree

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Shows how to traverse the DOM tree using methods like children() and getElementById(), demonstrating chained calls to access deeply nested elements.

```PHP
// Example
echo $html->find("#div1", 0)->children(1)->children(1)->children(2)->id;
// or
echo $html->getElementById("div1")->childNodes(1)->childNodes(1)->childNodes(2)->getAttribute('id');
```

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

### PHP: Create DOM Object (Object-Oriented Way)

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP snippet demonstrates the object-oriented approach to creating and loading a Simple HTML DOM object. It shows how to instantiate `simple_html_dom` and then load HTML content from a string, a URL, or a local HTML file using the `load()` and `load_file()` methods.

```php
// Create a DOM object
$html = new simple_html_dom();
  
// Load HTML from a string
$html->load('<html><body>Hello!</body></html>');
  
// Load HTML from a URL
$html->load_file('http://www.google.com/');
  
// Load HTML from a HTML file
$html->load_file('test.htm');
```

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

### PHP Simple HTML DOM Parser Helper Functions

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_api.htm

Functions for creating DOM objects from strings or files/URLs.

```APIDOC
str_get_html(content: string): object
  content: The HTML content as a string.
  Returns: A DOM object.

file_get_html(filename: string): object
  filename: The path to the file or a URL.
  Returns: A DOM object.
```

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

### DOM Traversal Methods API

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Reference for methods used to navigate the DOM tree, including accessing children, parent, first/last child, and next/previous siblings.

```APIDOC
Method
  mixed $e->children ( [int $index] )
    Description: Returns the Nth child object if index is set, otherwise return an array of children.
  element $e->parent ()
    Description: Returns the parent of element.
  element $e->first_child ()
    Description: Returns the first child of element, or null if not found.
  element $e->last_child ()
    Description: Returns the last child of element, or null if not found.
  element $e->next_sibling ()
    Description: Returns the next sibling of element, or null if not found.
  element $e->prev_sibling ()
    Description: Returns the previous sibling of element, or null if not found.
```

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

### Selecting HTML Elements with find()

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Demonstrates various ways to select elements using the find() method, including nested elements, elements with specific classes, elements with attributes, and special text/comment blocks.

```PHP
// Find all <li> in <ul>
$es = $html->find('ul li');
```

```PHP
// Find Nested <div> tags
$es = $html->find('div div div');
```

```PHP
// Find all <td> in <table> which class=hello
$es = $html->find('table.hello td');
```

```PHP
// Find all td tags with attribite align=center in table tags
$es = $html->find('table td[align=center]');
```

```PHP
// Find all text blocks
$es = $html->find('text');
```

```PHP
// Find all comment (<!--...-->) blocks
$es = $html->find('comment');
```

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

### PHP Simple HTML DOM Parser Element Object API

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_api.htm

Methods and properties for reading, writing, and traversing individual HTML elements.

```APIDOC
[attribute]: string
  Description: Reads or writes the element's attribute value.

tag: string
  Description: Reads or writes the tag name of the element.

outertext: string
  Description: Reads or writes the outer HTML text of the element.

innertext: string
  Description: Reads or writes the inner HTML text of the element.

plaintext: string
  Description: Reads or writes the plain text of the element.

find(selector: string, index: int = null): mixed
  selector: The CSS selector to find children by.
  index: Optional. If set, returns the Nth element object.
  Returns: The Nth element object if index is set, otherwise an array of objects.
```

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

### PHP Simple HTML DOM Parser DOM Traversing API

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_api.htm

Methods for navigating the DOM tree relative to an element.

```APIDOC
$e->children(index: int = null): mixed
  index: Optional. If set, returns the Nth child object.
  Returns: The Nth child object if index is set, otherwise an array of children.

$e->parent(): element
  Returns: The parent of the element.

$e->first_child(): element
  Returns: The first child of the element, or null if not found.

$e->last_child(): element
  Returns: The last child of the element, or null if not found.

$e->next_sibling(): element
  Returns: The next sibling of the element, or null if not found.

$e->prev_sibling(): element
  Returns: The previous sibling of the element, or null if not found.
```

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

### PHP Simple HTML DOM Parser Camel Case Method Mappings

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_api.htm

Mapping of W3C standard camel naming conventions to the PHP Simple HTML DOM Parser's internal snake_case methods.

```APIDOC
$e->getAllAttributes() -> $e->attr: array
$e->getAttribute(name: string) -> $e->attribute: string
$e->setAttribute(name: string, value: string) -> $e->attribute = $value: void
$e->hasAttribute(name: string) -> isset($e->attribute): bool
$e->removeAttribute(name: string) -> $e->attribute = null: void
$e->getElementById(id: string) -> $e->find("#$id", 0): element
$e->getElementsById(id: string, index: int = null) -> $e->find("#$id", index): mixed
$e->getElementByTagName(name: string) -> $e->find($name, 0): element
$e->getElementsByTagName(name: string, index: int = null) -> $e->find($name, index): mixed
$e->parentNode() -> $e->parent(): element
$e->childNodes(index: int = null) -> $e->children(index): mixed
$e->firstChild() -> $e->first_child(): element
$e->lastChild() -> $e->last_child(): element
$e->nextSibling() -> $e->next_sibling(): element
$e->previousSibling() -> $e->prev_sibling(): element
```

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

### PHP Simple HTML DOM Parser: Accessing URLs Behind a Proxy

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_faq.htm

This solution shows how to configure PHP's stream context to enable `file_get_html()` to access URLs when the server is operating behind an HTTP proxy. It defines proxy settings within the stream context, allowing the parser to fetch content through the specified proxy.

```PHP
$context = array
(
     'http' => array
     (
          'proxy' => 'addresseproxy:portproxy', // This needs to be the server and the port of the NTLM Authentication Proxy Server.
          'request_fulluri' => true,
     ),
);

$context = stream_context_create($context);

$html= file_get_html('http://www.php.net', false, $context);
// ...
```

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

### PHP Simple HTML DOM Parser DOM Object API

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_api.htm

Methods and properties available on the main DOM object for loading, saving, manipulating, and querying HTML content.

```APIDOC
__construct(filename: string = null): void
  filename: Optional. The filename or URL to load content from upon construction.

plaintext: string
  Description: Returns the plain text content extracted from the HTML.

clear(): void
  Description: Cleans up memory used by the DOM object.

load(content: string): void
  content: The HTML content as a string to load into the DOM object.

save(filename: string = null): string
  filename: Optional. If set, the result string will be saved to this file.
  Returns: The internal DOM tree dumped back into a string.

load_file(filename: string): void
  filename: The path to the file or a URL to load content from.

set_callback(function_name: string): void
  function_name: The name of the callback function to set.

find(selector: string, index: int = null): mixed
  selector: The CSS selector to find elements by.
  index: Optional. If set, returns the Nth element object.
  Returns: The Nth element object if index is set, otherwise an array of objects.
```

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

### PHP: Find HTML Elements with Advanced Selectors

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP snippet demonstrates more advanced usage of the `find()` method, including CSS-like selectors. It shows how to find elements by ID (`#foo`), by class (`.foo`), by any element with a specific attribute (`*[id]`), and by multiple tag or attribute selectors combined (`a, img` or `a[title], img[title]`).

```php
// Find all element which id=foo
$ret = $html->find('#foo');
  
// Find all element which class=foo
$ret = $html->find('.foo');
  
// Find all element has attribute id
$ret = $html->find('*[id]');
  
// Find all anchors and images
$ret = $html->find('a, img');
  
// Find all anchors and images with the "title" attribute
$ret = $html->find('a[title], img[title]');
```

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

### PHP: Find HTML Elements with Basic Selectors

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP snippet illustrates basic usage of the `find()` method to locate HTML elements. It covers finding all elements of a specific tag, finding the Nth or last element, and finding elements based on the presence or exact value of an ID attribute.

```php
// Find all anchors, returns a array of element objects
$ret = $html->find('a');
  
// Find (N)th anchor, returns element object or null if not found (zero based)
$ret = $html->find('a', 0);
  
// Find lastest anchor, returns element object or null if not found (zero based)
$ret = $html->find('a', -1);
  
// Find all <div> with the id attribute
$ret = $html->find('div[id]');
  
// Find all <div> which attribute id=foo
$ret = $html->find('div[id=foo]');
```

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

### JavaScript: Initialize jQuery UI Tabs for Manual Sections

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This JavaScript snippet uses jQuery to initialize tab functionality for various sections within the PHP Simple HTML DOM Parser manual. It targets specific `div` containers by their IDs and applies the `tabs()` method to their unordered lists.

```javascript
$(document).ready(function(){ $(function() {$('#container_quickstart > ul').tabs();}); $(function() {$('#container_create > ul').tabs();}); $(function() {$('#container_find > ul').tabs();}); $(function() {$('#container_access > ul').tabs();}); $(function() {$('#container_traverse > ul').tabs();}); $(function() {$('#container_dump > ul').tabs();}); $(function() {$('#container_callback > ul').tabs();}); });
```

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

### Setting a Callback Function for HTML Processing in PHP

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

This PHP code snippet illustrates the usage of the `set_callback` method to register a custom function that will be invoked during the HTML dumping process. This allows developers to inject custom logic or transformations before the final HTML output is generated.

```PHP
$html->set_callback('my_callback');

// Callback function will be invoked while dumping
echo $html;
```

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

### PHP Simple HTML DOM Parser: Quoting Selectors with Blanks

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_faq.htm

This snippet demonstrates the correct way to quote selectors in the `find()` method when they contain blank spaces, ensuring elements are properly located. It addresses issues where elements might not be found due to unquoted spaces in attribute values.

```PHP
$html->find('div[style="padding: 0px 2px;"] span[class=rf]');
```

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

### Special Element Attributes Reference

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual.htm

Documentation for special 'magic' attributes that allow reading or writing core properties of an HTML element, such as its tag name, outer HTML, inner HTML, and plain text content.

```PHP
// Example
$html = str_get_html("<div>foo <b>bar</b></div>");
$e = $html->find("div", 0);

echo $e->tag; // Returns: " div"
echo $e->outertext; // Returns: " <div>foo <b>bar</b></div>"
echo $e->innertext; // Returns: " foo <b>bar</b>"
echo $e->plaintext; // Returns: " foo bar"
```

```APIDOC
Attribute Name
  $e->tag
    Usage: Read or write the tag name of element.
  $e->outertext
    Usage: Read or write the outer HTML text of element.
  $e->innertext
    Usage: Read or write the inner HTML text of element.
  $e->plaintext
    Usage: Read or write the plain text of element.
```

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

### PHP Simple HTML DOM Parser: Releasing Memory

Source: https://github.com/yuzdzhan/htmltodocx/blob/master/simplehtmldom/manual/manual_faq.htm

This snippet addresses memory leak issues in PHP 5 related to circular references when using the DOM parser. It demonstrates the essential steps of calling `$html->clear()` and `unset($html)` to properly free memory after processing a DOM object, especially when `file_get_dom()` is invoked multiple times.

```PHP
$html = file_get_html(...);
// do something...
$html->clear();
unset($html);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.