### Default HtmlSanitizer Instance

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/lib.rs.html

Provides a globally accessible, lazily initialized `HtmlSanitizer` instance using the default allow list. This is useful for quick sanitization without explicit setup.

```rust
fn default_sanitizer() -> &'static HtmlSanitizer {
    static INSTANCE: OnceLock<HtmlSanitizer> = OnceLock::new();
    INSTANCE.get_or_init(HtmlSanitizer::new)
}
```

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

### Get Allowed Tag

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Retrieves the allowed `Tag` configuration based on the current `tag_idx`. Returns `None` if `tag_idx` is not set.

```rust
fn tag(&self) -> Option<&Tag> {
    self.tag_idx.map(|i| &self.allow_list.tags[i])
}
```

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

### Handle Less-Than Sign State

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Manages the state immediately after encountering a '<' character. It determines if it's the start of a closing tag ('/'), a non-HTML tag, or a new tag name.

```rust
fn s_lt_sign(&mut self, data: &[u8], off: &mut usize) -> io::Result<()> {
        let b = data[*off];
        match b {
            b'/' => {
                *off += 1;
                self.state = State::ETagStart;
                self.tag_name.clear();
            }
            _ if self.non_html_tag_idx.is_some() => {
                self.state = State::NonHtml;
                if self.keep_non_html {
                    self.buf.extend_from_slice(b"&lt;");
                }
            }
            _ => {
                *off += 1;
                if legal_keyword_byte(b) {
                    self.state = State::TagName;
                    self.tag_name.clear();
                    self.tag_name.push(b);
                    self.tag_idx = None;
                    return Ok(());
                }
                self.state = State::ErrTag;
            }
        }
        Ok(())
    }
```

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

### Start of an End Tag

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Initiates the processing of an end tag, checking for valid keyword bytes and handling non-HTML tags.

```rust
fn s_etag_start(&mut self, data: &[u8], off: &mut usize) -> io::Result<()> {
        let b = data[*off];
        if legal_keyword_byte(b) {
            *off += 1;
            self.tag_name.clear();
            self.tag_name.push(b);
            self.state = State::ETagName;
        } else if self.non_html_tag_idx.is_some() {
            self.state = State::NonHtml;
            if self.keep_non_html {
                self.buf.extend_from_slice(b"&lt;/");
            }
        } else {
            self.state = State::ErrTag;
        }
        Ok(())
    }
```

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

### Try Unescape HTML Entity

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Attempts to unescape a single HTML entity starting at the given byte position. It distinguishes between numeric and named entities.

```rust
fn try_unescape_entity(bytes: &[u8], start: usize) -> Option<(String, usize)> {
    let rest = &bytes[start..];
    if rest.len() < 2 {
        return None;
    }

    // Numeric character reference: &#...
    if rest[1] == b'#' {
        return try_unescape_numeric(rest);
    }

    // Named character reference
    try_unescape_named(rest)
}
```

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

### Create Default HTML Allow List

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/tags.rs.html

Initializes a default `AllowList` that mirrors the Go `DefaultAllowList`, pre-populating it with common HTML tags and their allowed attributes.

```rust
pub fn default_allow_list() -> AllowList {
    AllowList {
        tags: vec![
            Tag::new("address", &[], &[]),
            Tag::new("article", &[], &[]),
            Tag::new("aside", &[], &[]),
            Tag::new("footer", &[], &[]),
            Tag::new("header", &[], &[]),
            Tag::new("h1", &[], &[]),
            Tag::new("h2", &[], &[]),
            Tag::new("h3", &[], &[]),
            Tag::new("h4", &[], &[]),
            Tag::new("h5", &[], &[]),
            Tag::new("h6", &[], &[]),
            Tag::new("hgroup", &[], &[]),
            Tag::new("main", &[], &[]),
            Tag::new("nav", &[], &[]),
            Tag::new("section", &[], &[]),
            Tag::new("blockquote", &[], &["cite"]),
            Tag::new("dd", &[], &[]),
            Tag::new("div", &[], &[]),
            Tag::new("dl", &[], &[]),
            Tag::new("dt", &[], &[]),
            Tag::new("figcaption", &[], &[]),
            Tag::new("figure", &[], &[]),
            Tag::new("hr", &[], &[]),
            Tag::new("li", &[], &[]),
            Tag::new("ol", &[], &[]),
        ],
        global_attr: vec![],
        non_html_tags: vec![],
        tag_map: None,
        non_html_tag_map: None,
    }
}
```

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

### Get Non-HTML Tag Name

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Retrieves the name of the current non-HTML tag being processed. Returns `None` if `non_html_tag_idx` is not set.

```rust
fn non_html_tag_name(&self) -> Option<&str> {
    self.non_html_tag_idx
        .map(|i| self.allow_list.non_html_tags[i].name.as_str())
}
```

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

### default_allow_list

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/fn.default_allow_list.html

Creates the default allow list matching the Go `DefaultAllowList`.

```APIDOC
## Function default_allow_list

### Summary
```rust
pub fn default_allow_list() -> AllowList
```

### Description
Create the default allow list matching the Go `DefaultAllowList`.
```

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

### Create New HtmlSanitizer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Instantiate a new HtmlSanitizer with the default allow list.

```rust
pub fn new() -> Self
```

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

### HtmlSanitizer::new

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/lib.rs.html

Creates a new HtmlSanitizer instance with the default allow list and a default URL sanitizer.

```APIDOC
/// Create a new sanitizer with a clone of the default allow list.
pub fn new() -> Self
```

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

### HtmlSanitizer::new

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Creates a new HtmlSanitizer instance with a clone of the default allow list.

```APIDOC
## HtmlSanitizer::new

### Description
Create a new sanitizer with a clone of the default allow list.

### Method
`pub fn new() -> Self`
```

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

### Try Convert AllowList

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Attempts to convert a value into `AllowList`. Returns `Ok(AllowList)` on success or an error if the conversion fails.

```rust
type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

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

### Tag::new

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.Tag.html

Constructs a new Tag instance with the specified name and allowed attributes.

```APIDOC
### impl Tag

#### pub fn new(name: &str, attr: &[&str], url_attr: &[&str]) -> Self
Creates a new Tag.
```

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

### Create a New Tag Instance

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.Tag.html

Constructs a new Tag instance with specified allowed attributes. Ensure attribute names are lowercase for consistency.

```rust
pub fn new(name: &str, attr: &[&str], url_attr: &[&str]) -> Self
```

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

### Initialize SanitizeWriter

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Creates a new `SanitizeWriter` instance with the provided writer, allow list, and URL sanitizer function. Initializes the internal state for HTML sanitization.

```rust
pub fn new(w: W, allow_list: AllowList, url_sanitizer: UrlSanitizerFn) -> Self {
    Self {
        allow_list,
        url_sanitizer,
        w,
        state: State::Normal,
        tag_name: Vec::new(),
        tag_idx: None,
        non_html_tag_idx: None,
        keep_non_html: false,
        attr: Vec::new(),
        val: Vec::new(),
        quote: 0,
        last_byte: 0,
        buf: Vec::new(),
    }
}
```

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

### Configure HtmlSanitizer with Custom URL Sanitizer

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/lib.rs.html

Creates a new `HtmlSanitizer` and sets a custom URL sanitizer function. The function should return `Some(String)` with the sanitized URL or `None` to disallow it.

```rust
pub fn with_url_sanitizer<F>(mut self, f: F) -> Self
    where
        F: Fn(&str) -> Option<String> + Send + Sync + 'static,
    {
        self.url_sanitizer = Arc::new(f);
        self
    }
```

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

### URL Path and Query Parsing

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/url.rs.html

Parses a raw URL string to separate the path, query, and fragment components. Handles potential encoding issues before further processing.

```rust
            let (raw_url, fragment) = match raw_url.find('#') {
                Some(pos) => (&raw_url[..pos], Some(&raw_url[pos + 1..])),
                None => (raw_url, None),
            };
            let (path_part, query) = match rest.find('?') {
                Some(pos) => (&rest[..pos], Some(&rest[pos + 1..])),
                None => (rest, None),
            };

            // Percent-decode the path first (in case it had existing encoding),
            // then re-encode using Go rules
            let decoded = percent_decode(path_part);
            let mut result = go_path_encode(&decoded);

            if let Some(q) = query {
                result.push('?');
                result.push_str(q);
            }
            if let Some(f) = fragment {
                result.push('#');
                result.push_str(f);
            }

            Some(result)
        }
        Err(_) => None,
    }
}
```

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

### Create HtmlSanitizer with Custom URL Sanitizer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Create a new sanitizer instance and provide a custom URL sanitizer function. The function takes a URL string and returns an optional sanitized URL string.

```rust
pub fn with_url_sanitizer<F>(self, f: F) -> Self
where F: Fn(&str) -> Option<String> + Send + Sync + 'static,
```

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

### Clone AllowList

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Creates a deep copy of the `AllowList`. Use this when you need an independent copy of the sanitization rules.

```rust
fn clone(&self) -> AllowList
```

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

### impl AllowList

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Methods available for the AllowList struct.

```APIDOC
pub fn attr_exists(&self, name: &[u8]) -> bool
Check whether a global attribute exists.

pub fn check_non_html_tag(&mut self, name: &str) -> Option<usize>
Check if a tag name is a non-HTML tag (e.g. `script`, `style`). The name must already be lowercased.

pub fn add_tag(&mut self, tag: Tag)
Add a tag to the allow list.

pub fn remove_tag(&mut self, name: &str)
Remove all tags with the given name (must be lowercase).

pub fn find_tag(&mut self, name: &str) -> Option<usize>
Find a tag by its lowercased name.
```

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

### Unsafe Clone to Uninit

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Nightly-only experimental function to clone the `AllowList` into an uninitialized memory location. Use with extreme caution.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### SanitizeWriter::new Constructor

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Creates a new SanitizeWriter instance. It requires a writer, an AllowList, and a URL sanitizer function.

```rust
pub fn new( w: W, allow_list: AllowList, url_sanitizer: Arc<dyn Fn(&str) -> Option<String> + Send + Sync>, ) -> Self
```

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

### impl Default for HtmlSanitizer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Provides a default value for HtmlSanitizer, which is equivalent to calling `HtmlSanitizer::new()`.

```APIDOC
## impl Default for HtmlSanitizer

### Description
Returns the “default value” for a type.

### Method
`fn default() -> Self`
```

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

### SanitizeWriter::new

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Constructs a new SanitizeWriter. It takes an underlying writer, an AllowList for sanitization rules, and a URL sanitizer function.

```APIDOC
## fn new<W: Write>(w: W, allow_list: AllowList, url_sanitizer: Arc<dyn Fn(&str) -> Option<String> + Send + Sync>) -> Self

Constructs a new SanitizeWriter.

### Parameters
- `w`: The underlying writer to which sanitized content will be written.
- `allow_list`: An `AllowList` specifying which HTML tags and attributes are permitted.
- `url_sanitizer`: A function that sanitizes URLs found in attributes like `href` or `src`.
```

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

### AllowList Fields

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Details the fields within the AllowList struct.

```APIDOC
tags: Vec<Tag> - Allowed tags.
global_attr: Vec<String> - Globally allowed attributes (e.g. `class`, `id`).
non_html_tags: Vec<Tag> - Non-HTML tags like `<script>`, `<style>` whose content is not real HTML.
```

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

### Create SanitizeWriter

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Generate a `SanitizeWriter` that wraps a given writer. This allows for sanitizing HTML content as it's written.

```rust
pub fn new_writer<W: Write>(&self, w: W) -> SanitizeWriter<W>
```

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

### State: AttrSpace Handling

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Handles whitespace after an attribute name. It looks for '=', whitespace, or a keyword byte. If '=', it transitions to EqualSign. If whitespace, it continues. If a keyword byte or '>', it emits the bare attribute and transitions accordingly.

```Rust
    fn s_attr_space(&mut self, data: &[u8], off: &mut usize) -> io::Result<()> {
        while *off < data.len() {
            let b = data[*off];
            if b == b'=' {
                *off += 1;
                self.state = State::EqualSign;
                return Ok(());
            }
            if b.is_ascii_whitespace() {
                *off += 1;
                continue;
            }
            if legal_keyword_byte(b) || b == b'>' {
                self.emit_bare_attr_if_allowed();

                if b == b'>' {
                    self.state = State::TagEnd;
                    return Ok(());
                }

                *off += 1;
                self.attr.clear();
                self.attr.push(b);
                self.state = State::AttrName;
                return Ok(());
            }
            // default
            self.emit_bare_attr_if_allowed();

            *off += 1;
            self.last_byte = b;
            self.state = State::AttrGap;
            return Ok(());
        }
        Ok(())
    }
```

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

### Create SanitizeWriter

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/lib.rs.html

Generates a `SanitizeWriter` that wraps an existing `Write` implementor. This writer will sanitize HTML content as it's written to it.

```rust
pub fn new_writer<W: std::io::Write>(&self, w: W) -> SanitizeWriter<W> {
        SanitizeWriter::new(w, self.allow_list.clone(), self.url_sanitizer.clone())
    }
```

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

### default_url_sanitizer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/url/index.html

Provides a default URL sanitizer that accepts http, https, or empty schemes. It rejects opaque URIs and other schemes, mirroring the behavior of Go's DefaultURLSanitizer.

```APIDOC
## Function: default_url_sanitizer

### Description
Default URL sanitizer. Accepts http, https, or empty scheme. Rejects opaque URIs and other schemes. Matches Go’s DefaultURLSanitizer behavior.

### Usage
This function can be called directly to sanitize URLs according to the default policy.
```

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

### HtmlSanitizer::with_url_sanitizer

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/lib.rs.html

Creates a new HtmlSanitizer instance and sets a custom URL sanitizer function.

```APIDOC
/// Create a new sanitizer with a custom URL sanitizer.
pub fn with_url_sanitizer<F>(mut self, f: F) -> Self
where
    F: Fn(&str) -> Option<String> + Send + Sync + 'static,
```

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

### HtmlSanitizer::with_url_sanitizer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Creates a new HtmlSanitizer instance with a custom URL sanitizer function.

```APIDOC
## HtmlSanitizer::with_url_sanitizer

### Description
Create a new sanitizer with a custom URL sanitizer.

### Method
`pub fn with_url_sanitizer<F>(self, f: F) -> Self`

### Type Parameters
* `F`: A closure that takes a `&str` and returns an `Option<String>`, and must be `Send + Sync + 'static`.
```

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

### Manage HTML Allow List

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/tags.rs.html

Defines the `AllowList` struct to manage allowed HTML tags and global attributes. It includes methods to build internal maps for efficient lookups and to modify the list by adding or removing tags.

```rust
pub struct AllowList {
    /// Allowed tags.
    pub tags: Vec<Tag>,
    /// Globally allowed attributes (e.g. `class`, `id`).
    pub global_attr: Vec<String>,
    /// Non-HTML tags like `<script>`, `<style>` whose content is not real HTML.
    pub non_html_tags: Vec<Tag>,

    tag_map: Option<HashMap<String, usize>>,
    non_html_tag_map: Option<HashMap<String, usize>>,
}

impl AllowList {
    fn build_tag_map(&mut self) {
        let mut map = HashMap::with_capacity(self.tags.len());
        for (i, tag) in self.tags.iter().enumerate() {
            map.insert(tag.name.clone(), i);
        }
        self.tag_map = Some(map);
    }

    fn build_non_html_tag_map(&mut self) {
        let mut map = HashMap::with_capacity(self.non_html_tags.len());
        for (i, tag) in self.non_html_tags.iter().enumerate() {
            map.insert(tag.name.clone(), i);
        }
        self.non_html_tag_map = Some(map);
    }

    /// Check whether a global attribute exists.
    pub fn attr_exists(&self, name: &[u8]) -> bool {
        let name = std::str::from_utf8(name).unwrap_or("");
        self.global_attr.iter().any(|a| a == name)
    }

    /// Check if a tag name is a non-HTML tag (e.g. `script`, `style`).
    /// The name must already be lowercased.
    pub fn check_non_html_tag(&mut self, name: &str) -> Option<usize> {
        if self.non_html_tag_map.is_none() {
            self.build_non_html_tag_map();
        }
        self.non_html_tag_map.as_ref().unwrap().get(name).copied()
    }

    /// Add a tag to the allow list.
    pub fn add_tag(&mut self, tag: Tag) {
        self.tags.push(tag);
        self.tag_map = None;
    }

    /// Remove all tags with the given name (must be lowercase).
    pub fn remove_tag(&mut self, name: &str) {
        self.tags.retain(|t| t.name != name);
        self.tag_map = None;
    }

    /// Find a tag by its lowercased name.
    pub fn find_tag(&mut self, name: &str) -> Option<usize> {
        if self.tag_map.is_none() {
            self.build_tag_map();
        }
        self.tag_map.as_ref().unwrap().get(name).copied()
    }
}
```

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

### Clone From Another AllowList

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Efficiently copies the contents of another `AllowList` into the current one. This is an optimized assignment operation.

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Blanket Implementations for Tag

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.Tag.html

Showcases generic trait implementations that apply to Tag, such as Any, Borrow, CloneToUninit, From, Into, ToOwned, TryFrom, and TryInto. These enable Tag to interact with other parts of the Rust ecosystem.

```rust
impl<T> Any for T
where T: 'static + ?Sized
```

```rust
fn type_id(&self) -> TypeId
```

```rust
impl<T> Borrow<T> for T
where T: ?Sized
```

```rust
fn borrow(&self) -> &T
```

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized
```

```rust
fn borrow_mut(&mut self) -> &mut T
```

```rust
impl<T> CloneToUninit for T
where T: Clone
```

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

```rust
impl<T, U> Into<U> for T
where U: From<T>
```

```rust
fn into(self) -> U
```

```rust
impl<T> ToOwned for T
where T: Clone
```

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

```rust
fn clone_into(&self, target: &mut T)
```

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>
```

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>
```

```rust
type Error = <U as TryFrom<T>>::Error
```

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### SanitizeWriter::by_ref Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Creates a "by reference" adapter for the SanitizeWriter instance. This is part of the Write trait.

```rust
fn by_ref(&mut self) -> &mut Self
where Self: Sized,
```

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

### Clone Tag Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.Tag.html

Provides the ability to duplicate a Tag instance. This is a standard implementation for types that can be copied.

```rust
fn clone(&self) -> Tag
```

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Default HtmlSanitizer Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Provides a default value for HtmlSanitizer, typically using a predefined configuration.

```rust
fn default() -> Self
```

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

### AllowList Structure

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/tags.rs.html

Defines the complete set of allowed HTML tags and attributes for the sanitizer.

```APIDOC
## struct AllowList

### Description
Specifies all allowed HTML tags and attributes for the sanitizer.

### Fields
- **tags** (Vec<Tag>) - Allowed tags.
- **global_attr** (Vec<String>) - Globally allowed attributes (e.g. `class`, `id`).
- **non_html_tags** (Vec<Tag>) - Non-HTML tags like `<script>`, `<style>` whose content is not real HTML.

### Methods
#### attr_exists(&self, name: &[u8]) -> bool
Checks whether a global attribute exists.

#### check_non_html_tag(&mut self, name: &str) -> Option<usize>
Checks if a tag name is a non-HTML tag (e.g. `script`, `style`). The name must already be lowercased.

#### add_tag(&mut self, tag: Tag)
Adds a tag to the allow list.

#### remove_tag(&mut self, name: &str)
Removes all tags with the given name (must be lowercase).

#### find_tag(&mut self, name: &str) -> Option<usize>
Finds a tag by its lowercased name.
```

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

### Debug Implementation for Tag

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.Tag.html

Enables the Tag struct to be formatted for debugging purposes. This is useful for inspecting tag configurations.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

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

### Generic Implementations for Tag

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.Tag.html

Includes standard Rust trait implementations like Send, Sync, Unpin, and others that ensure Tag can be safely used in various concurrent and memory-managed contexts.

```rust
impl Freeze for Tag
```

```rust
impl RefUnwindSafe for Tag
```

```rust
impl Send for Tag
```

```rust
impl Sync for Tag
```

```rust
impl Unpin for Tag
```

```rust
impl UnsafeUnpin for Tag
```

```rust
impl UnwindSafe for Tag
```

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

### AllowList Struct Definition

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Defines the structure of AllowList, which holds configurations for allowed tags and attributes.

```APIDOC
struct AllowList {
    pub tags: Vec<Tag>,
    pub global_attr: Vec<String>,
    pub non_html_tags: Vec<Tag>,
}
```

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

### sanitize

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/fn.sanitize.html

Sanitizes HTML bytes with the default allow list.

```APIDOC
## sanitize

### Description
Convenience: sanitize HTML bytes with the default allow list.

### Signature
```rust
pub fn sanitize(data: &[u8]) -> Vec<u8>
```
```

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

### Create Owned AllowList

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Creates an owned version of the `AllowList`, typically by cloning. This is part of the `ToOwned` trait.

```rust
fn to_owned(&self) -> T
```

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

### SanitizeWriter::write_all_vectored Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Attempts to write multiple buffers into the SanitizeWriter. This is a nightly-only experimental API.

```rust
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
```

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

### Re-exports

Source: https://docs.rs/htmlsanitizer/latest/index.html

Key types and functions re-exported for direct use.

```APIDOC
## Re-exports

`pub use dfa::SanitizeWriter;`

`pub use tags::default_allow_list;`

`pub use tags::AllowList;`

`pub use tags::Tag;`

`pub use url::default_url_sanitizer;`
```

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

### State: EqualSign Handling

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Handles the state after an attribute name, expecting an equals sign. Transitions to AttrQVal for quoted values, ValSpace for whitespace, or AttrVal for unquoted values.

```Rust
        self.val.clear();
        let b = data[*off];

        if b == b'>' {
            self.safe_append_attr();
            self.state = State::TagEnd;
        } else if b == b'\' || b == b'"' {
            *off += 1;
            self.quote = b;
            self.state = State::AttrQVal;
        } else if b.is_ascii_whitespace() {
            *off += 1;
            self.state = State::ValSpace;
        } else {
            *off += 1;
            self.state = State::AttrVal;
            self.val.push(b);
        }
        Ok(())
    }
```

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

### Find a Tag by Name

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Searches for a tag within the allow list by its lowercased name. Returns the index of the tag if found.

```rust
pub fn find_tag(&mut self, name: &str) -> Option<usize>
```

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

### AllowList Struct Definition

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Defines the structure for specifying allowed HTML tags and attributes. Use this to configure the sanitizer's behavior.

```rust
pub struct AllowList {
    pub tags: Vec<Tag>,
    pub global_attr: Vec<String>,
    pub non_html_tags: Vec<Tag>,
    /* private fields */
}
```

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

### State: TagEnd Handling

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Handles the transition to the TagEnd state when a '>' character is encountered after processing a tag or attribute.

```Rust
            let b = data[*off];
            if b == b'>' {
                self.state = State::TagEnd;
                return Ok(());
            }
            if legal_keyword_byte(b) {
                *off += 1;
                self.attr.clear();
                self.attr.push(b);
                self.state = State::AttrName;
                return Ok(());
            }
            self.last_byte = b;
            *off += 1;
        }
        Ok(())
```

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

### SanitizeWriter::write_all Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Attempts to write an entire buffer into the SanitizeWriter. This method is part of the Write trait.

```rust
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
```

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

### Struct: HtmlSanitizer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/index.html

Represents an HTML sanitizer with a configurable allow list and URL sanitizer.

```APIDOC
struct HtmlSanitizer
```

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

### HtmlSanitizer Struct

Source: https://docs.rs/htmlsanitizer/latest/index.html

Represents an HTML sanitizer with a configurable allow list and URL sanitizer.

```APIDOC
## Struct HtmlSanitizer

### Description
HTML sanitizer with a configurable allow list and URL sanitizer.

### Fields
(Details about fields would be here if documented in the source)
```

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

### Write trait implementation for SanitizeWriter

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

SanitizeWriter implements the standard `Write` trait, allowing it to be used wherever a `Write`r is expected. This includes methods for writing buffers, flushing, and more.

```APIDOC
## impl<W: Write> Write for SanitizeWriter<W>

Implements the `Write` trait for `SanitizeWriter`.

### Methods

#### fn write(&mut self, p: &[u8]) -> Result<usize>
Writes a buffer into this writer, returning how many bytes were written.

#### fn flush(&mut self) -> Result<()>
Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

#### fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
Like `write`, except that it writes from a slice of buffers.

#### fn is_write_vectored(&self) -> bool
Determines if this `Write`r has an efficient `write_vectored` implementation.

#### fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
Attempts to write an entire buffer into this writer.

#### fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
Attempts to write multiple buffers into this writer.

#### fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>
Writes a formatted string into this writer, returning any error encountered.

#### fn by_ref(&mut self) -> &mut Self
Creates a “by reference” adapter for this instance of `Write`.
```

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

### Re-exports

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer

These items are re-exported from other modules and are available for direct use.

```APIDOC
pub use dfa::SanitizeWriter;

pub use tags::default_allow_list;
pub use tags::AllowList;
pub use tags::Tag;

pub use url::default_url_sanitizer;
```

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

### Handle Normal State

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Processes input data in the `Normal` state. Appends characters directly to the buffer, escaping `>` as `&gt;`. Transitions to `LtSign` state upon encountering `<`.

```rust
fn s_normal(&mut self, data: &[u8], off: &mut usize) -> io::Result<()> {
    while *off < data.len() {
        match data[*off] {
            b'<' => {
                self.state = State::LtSign;
                *off += 1;
                self.flush_buf()?;
                return Ok(());
            }
            b'>' => {
                self.buf.extend_from_slice(b"&gt;");
            }
            b => {
                self.buf.push(b);
            }
        }
        *off += 1;
    }
    self.flush_buf()
}
```

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

### Tag Structure

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/tags.rs.html

Represents a single HTML tag with its allowed attributes, including both regular and URL-related attributes.

```APIDOC
## struct Tag

### Description
A single HTML tag with its allowed attributes.

### Fields
- **name** (String) - Tag name (must be lowercase).
- **attr** (Vec<String>) - Allowed non-URL attributes (must be lowercase).
- **url_attr** (Vec<String>) - Allowed URL-related attributes (must be lowercase).

### Methods
#### new(name: &str, attr: &[&str], url_attr: &[&str]) -> Self
Creates a new Tag instance.

#### attr_exists(&self, name: &[u8]) -> (bool, bool)
Checks whether an attribute exists on this tag. Returns `(exists, is_url_attr)`.
```

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

### SanitizeWriter::write_fmt Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Writes a formatted string into the SanitizeWriter, returning any error encountered. This is part of the Write trait.

```rust
fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>
```

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

### Go-Style Path Encoding

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/url.rs.html

Percent-encodes a byte sequence according to Go's `net/url` `encodePath` rules. It escapes characters not in the allowed set (alphanumeric, `-`, `_`, `.`, `~`, `$`, `&`, `+`, `,`, `/`, `:`, `;`, `=`, `@`).

```rust
const HEX_DIGITS: &[u8; 16] = b"0123456789ABCDEF";

fn go_path_encode(s: &[u8]) -> String {
    let mut out = String::with_capacity(s.len());
    for &b in s {
        if b.is_ascii_alphanumeric()
            || matches!(b, b'-' | b'_' | b'.' | b'~')
            || matches!(
                b,
                b'$' | b'&' | b'+' | b',' | b'/' | b':' | b';' | b'=' | b'@'
            ) {
            out.push(b as char);
        } else {
            out.push('%');
            out.push(HEX_DIGITS[(b >> 4) as usize] as char);
            out.push(HEX_DIGITS[(b & 0x0F) as usize] as char);
        }
    }
    out
}
```

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

### Add a Tag to AllowList

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/tags/struct.AllowList.html

Adds a new `Tag` to the list of allowed tags. Ensure the `Tag` object is correctly constructed.

```rust
pub fn add_tag(&mut self, tag: Tag)
```

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

### Sanitize HTML String

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Sanitize an HTML string and return the cleaned-up version as a String.

```rust
pub fn sanitize_string(&self, data: &str) -> String
```

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

### SanitizeWriter From Trait Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Provides the from method for converting a type into itself. This is a blanket implementation.

```rust
fn from(t: T) -> T
```

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

### HtmlSanitizer::new_writer

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/lib.rs.html

Creates a new `SanitizeWriter` that wraps a given `std::io::Write` implementor. This writer will sanitize HTML as data is written to it.

```APIDOC
/// Create a new `SanitizeWriter` wrapping the given writer.
pub fn new_writer<W: std::io::Write>(&self, w: W) -> SanitizeWriter<W>
```

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

### Convert Bytes to Lowercase In Place

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/tags.rs.html

Provides a utility function to convert a mutable byte slice to its ASCII lowercase equivalent directly in memory.

```rust
pub fn ascii_lower_in_place(p: &mut [u8]) {
    p.make_ascii_lowercase();
}
```

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

### SanitizeWriter Into Trait Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Provides the into method for converting a type into another type that implements From. This is a blanket implementation.

```rust
fn into(self) -> U
where U: From<T>,
```

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

### Default URL Sanitizer

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/url.rs.html

Sanitizes a raw URL string, accepting only 'http' or 'https' schemes and rejecting opaque URIs. It aims to replicate the behavior of Go's `DefaultURLSanitizer`, including checks for control characters and percent-encoded host components.

```rust
pub fn default_url_sanitizer(raw_url: &str) -> Option<String> {
    // Reject URLs containing control characters (Go 1.17+)
    if contains_ctl_byte(raw_url) {
        return None;
    }

    // Try parsing as absolute URL first
    match Url::parse(raw_url) {
        Ok(u) => {
            // Reject opaque URIs (cannot-be-a-base)
            if u.cannot_be_a_base() {
                return None;
            }
            match u.scheme() {
                "http" | "https" => {
                    // Reject percent-encoded ASCII in host (Go rejects these)
                    if let Some(host) = u.host_str() {
                        let scheme_prefix = format!("{}://", u.scheme());
                        if let Some(after_scheme) = raw_url.strip_prefix(&scheme_prefix) {
                            let raw_host = after_scheme.split('/').next().unwrap_or("");
                            let raw_host = raw_host.split('?').next().unwrap_or(raw_host);
                            let raw_host = raw_host.split('#').next().unwrap_or(raw_host);
                            let raw_host = if let Some(pos) = raw_host.rfind('@') {
                                &raw_host[pos + 1..]
                            } else {
                                raw_host
                            };
                            if raw_host != host && !raw_host.eq_ignore_ascii_case(host) {
                                return None;
                            }
                        }
                    }
                    Some(u.to_string())
                }
                _ => None,
            }
        }
        Err(url::ParseError::RelativeUrlWithoutBase) => {
            // Go rejects relative URLs where the first path segment contains ':'
            if first_segment_has_colon(raw_url) {
                return None;
            }

            // Validate by parsing against a dummy base
            let base = Url::parse("http://x.invalid/").unwrap();
            if base.join(raw_url).is_err() {
                return None;
            }

            // Re-serialize using Go-compatible encoding.
            // Split raw URL into path, query, fragment, then re-encode the path.
            let (rest, fragment) = match raw_url.find('#') {

```

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

### sanitize (convenience function)

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/lib.rs.html

A convenience function to sanitize HTML bytes using the default `HtmlSanitizer` instance.

```APIDOC
/// Convenience: sanitize HTML bytes with the default allow list.
pub fn sanitize(data: &[u8]) -> Vec<u8>
```

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

### Default for HtmlSanitizer

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/lib.rs.html

Implements the `Default` trait for `HtmlSanitizer`, allowing it to be created using `HtmlSanitizer::default()`, which is equivalent to `HtmlSanitizer::new()`.

```APIDOC
impl Default for HtmlSanitizer {
    fn default() -> Self {
        Self::new()
    }
}
```

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

### Define an HTML Tag with Attributes

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/tags.rs.html

Defines a `Tag` struct representing an HTML element, specifying its name and allowed attributes, including those that can contain URLs.

```rust
pub struct Tag {
    /// Tag name (must be lowercase).
    pub name: String,
    /// Allowed non-URL attributes (must be lowercase).
    pub attr: Vec<String>,
    /// Allowed URL-related attributes (must be lowercase).
    pub url_attr: Vec<String>,
}

impl Tag {
    pub fn new(name: &str, attr: &[&str], url_attr: &[&str]) -> Self {
        Self {
            name: name.to_string(),
            attr: attr.iter().map(|s| s.to_string()).collect(),
            url_attr: url_attr.iter().map(|s| s.to_string()).collect(),
        }
    }

    /// Check whether an attribute exists on this tag. Returns `(exists, is_url_attr)`.
    pub fn attr_exists(&self, name: &[u8]) -> (bool, bool) {
        let name = std::str::from_utf8(name).unwrap_or("");
        for a in &self.url_attr {
            if a == name {
                return (true, true);
            }
        }
        for a in &self.attr {
            if a == name {
                return (true, false);
            }
        }
        (false, false)
    }
}
```

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

### Sanitize HTML Bytes

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Process raw HTML data in byte format and return the sanitized output as a byte vector.

```rust
pub fn sanitize(&self, data: &[u8]) -> Vec<u8>
```

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

### Into Trait Implementation for HtmlSanitizer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Implements the `Into` trait, enabling conversion from `HtmlSanitizer` to types that can be created from it.

```rust
fn into(self) -> U
```

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

### Try Unescape Named Entity

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Parses and unescapes common named HTML entities (e.g., `&amp;`, `&lt;`). Uses a static, sorted list for efficient lookup.

```rust
fn try_unescape_named(rest: &[u8]) -> Option<(String, usize)> {
    // Common named entities used in HTML attribute values, sorted by name for binary search
    static ENTITIES: &[(&[u8], &str)] = &[
        (b"&NewLine;", "\n"),
        (b"&Tab;", "\t"),
        (b"&acute;", "\u{00B4}"),
        (b"&amp;", "&"),
        (b"&apos;", "'"),
        (b"&brvbar;", "\u{00A6}"),
        (b"&cedil;", "\u{00B8}"),
        (b"&cent;", "\u{00A2}"),
        (b"&colon;", ":"),
        (b"&comma;", ","),
        (b"&copy;", "\u{00A9}"),
        (b"&curren;", "\u{00A4}"),
        (b"&deg;", "\u{00B0}"),
        (b"&divide;", "\u{00F7}"),
        (b"&frac12;", "\u{00BD}"),
        (b"&frac14;", "\u{00BC}"),
        (b"&frac34;", "\u{00BE}"),
        (b"&gt;", ">"),
        (b"&iexcl;", "\u{00A1}"),
        (b"&iquest;", "\u{00BF}"),
        (b"&laquo;", "\u{00AB}"),
        (b"&lpar;", "("),
        (b"&lt;", "<"),
        (b"&macr;", "\u{00AF}"),
        (b"&micro;", "\u{00B5}"),
        (b"&middot;", "\u{00B7}"),
        (b"&nbsp;", "\u{00A0}"),
        (b"&not;", "\u{00AC}"),
        (b"&ordm;", "\u{00BA}"),
        (b"&ordf;", "\u{00AA}"),
        (b"&para;", "\u{00B6}"),
        (b"&period;", "."),
        (b"&plusmn;", "\u{00B1}"),
        (b"&pound;", "\u{00A3}"),
        (b"&quot;", "\""),
        (b"&raquo;", "\u{00BB}"),
        (b"&reg;", "\u{00AE}"),
        (b"&rpar;", ")"),
        (b"&sect;", "\u{00A7}"),
        (b"&semi;", ";"),
        (b"&shy;", "\u{00AD}"),
        (b"&sup1;", "\u{00B9}"),
        (b"&sup2;", "\u{00B2}"),
        (b"&sup3;", "\u{00B3}"),
        (b"&times;", "\u{00D7}"),
        (b"&uml;", "\u{00A8}"),
        (b"&yen;", "\u{00A5}"),
    ];

    for &(entity, replacement) in ENTITIES {
        if rest.len() >= entity.len() && &rest[..entity.len()] == entity {

```

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

### TryFrom Trait Implementation for HtmlSanitizer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Implements the `TryFrom` trait, allowing fallible conversion into `HtmlSanitizer` from other types.

```rust
type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

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

### HtmlSanitizer::new_writer

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/struct.HtmlSanitizer.html

Creates a new `SanitizeWriter` that wraps a given writer, allowing for streaming sanitization.

```APIDOC
## HtmlSanitizer::new_writer

### Description
Create a new `SanitizeWriter` wrapping the given writer.

### Method
`pub fn new_writer<W: Write>(&self, w: W) -> SanitizeWriter<W>`

### Type Parameters
* `W`: The type of the writer, which must implement the `Write` trait.
```

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

### Handle Non-HTML Content

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Processes characters when the sanitizer is not in an HTML tag context. It checks for '<' to transition to the LtSign state or appends characters to the buffer if `keep_non_html` is true.

```rust
fn s_non_html(&mut self, data: &[u8], off: &mut usize) -> io::Result<()> {
        while *off < data.len() {
            match data[*off] {
                b'<' => {
                    self.state = State::LtSign;
                    *off += 1;
                    self.flush_buf()?;
                    return Ok(());
                }
                b'>' => {
                    if self.keep_non_html {
                        self.buf.extend_from_slice(b"&gt;");
                    }
                }
                b => {
                    if self.keep_non_html {
                        self.buf.push(b);
                    }
                }
            }
            *off += 1;
        }
        self.flush_buf()
    }
```

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

### Re-exports

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/index.html

These types and functions are re-exported from other modules and are available for direct use.

```APIDOC
pub use dfa::SanitizeWriter;

pub use tags::default_allow_list;

pub use tags::AllowList;

pub use tags::Tag;

pub use url::default_url_sanitizer;
```

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

### Handle Attribute Gap State

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/dfa.rs.html

Manages the state between a tag name and its attributes, or between attributes. It looks for attribute names, '=', or the tag closing '>'.

```rust
fn s_attr_gap(&mut self, data: &[u8], off: &mut usize) -> io::Result<()> {
        while *off < data.len() {

```

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

### Percent-Decode URL Component

Source: https://docs.rs/htmlsanitizer/latest/src/htmlsanitizer/url.rs.html

Decodes a percent-encoded string (e.g., `%22` to `"`). It iterates through the string, converting percent-encoded sequences into their byte equivalents.

```rust
fn percent_decode(s: &str) -> Vec<u8> {
    let bytes = s.as_bytes();
    let mut out = Vec::with_capacity(bytes.len());
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b'%' && i + 2 < bytes.len() {
            if let (Some(hi), Some(lo)) = (hex_val(bytes[i + 1]), hex_val(bytes[i + 2])) {
                out.push((hi << 4) | lo);
                i += 3;
                continue;
            }
        }
        out.push(bytes[i]);
        i += 1;
    }
    out
}
```

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

### SanitizeWriter TryFrom Trait Implementation

Source: https://docs.rs/htmlsanitizer/latest/htmlsanitizer/dfa/struct.SanitizeWriter.html

Provides the try_from method for fallible conversion from one type to another. This is a blanket implementation.

```rust
type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
where U: Into<T>,
```