stringprep

https://docs.rs/stringprep/0.1.5/
Admin
A Rust implementation of the stringprep algorithm defined in RFC 3454 for string preparation and...
Tokens:30,722
Snippets:203
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Resourceprep: Basic String Preparation

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Prepares a string for use as a resource name according to Resourceprep rules. This example demonstrates a successful preparation.

```rust
assert_eq!("foo@bar", resourceprep("foo@bar").unwrap());
```

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

### X520prep: Basic String Preparation with Case Folding

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Prepares a string using X520prep rules with case folding enabled. This is useful for case-insensitive comparisons.

```rust
assert_eq!(x520prep("foo@bar", true).unwrap(), "foo@bar");
```

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

### X520prep: String Preparation with Complex Characters

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Demonstrates X520prep string preparation with various characters, including those requiring mapping and normalization, with case folding disabled.

```rust
assert_eq!(
            x520prep("J.\u{FE00} \u{9}W. \u{B}wuz h\u{0115}re", false).unwrap(),
            "J. W. wuz here"
        );
```

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

### resourceprep

Source: https://docs.rs/stringprep/0.1.5/stringprep/fn.resourceprep.html

Prepares a string with the Resourceprep profile of the stringprep algorithm.

```APIDOC
## resourceprep

### Description
Prepares a string with the Resourceprep profile of the stringprep algorithm. Nameprep is defined in RFC 3920, Appendix B.

### Signature
```rust
pub fn resourceprep(s: &str) -> Result<Cow<'_, str>, Error>
```

### Parameters
#### Path Parameters
- **s** (string) - The input string to prepare.

### Returns
- **Result<Cow<'_, str>, Error>** - A `Cow<'_, str>` containing the prepared string on success, or an `Error` on failure.
```

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

### Nameprep String Preparation

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Prepares a string using the Nameprep profile. Includes a fast path for strings containing only ASCII lowercase letters, digits, periods, and hyphens.

```rust
/// Prepares a string with the Nameprep profile of the stringprep algorithm.
///
/// Nameprep is defined in [RFC 3491][].
///
/// [RFC 3491]: https://tools.ietf.org/html/rfc3491
pub fn nameprep(s: &str) -> Result<Cow<'_, str>, Error> {
    // fast path for ascii text
    if s.chars()
        .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '.' || c == '-') {

```

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

### nameprep

Source: https://docs.rs/stringprep/0.1.5/stringprep/fn.nameprep.html

Prepares a string with the Nameprep profile of the stringprep algorithm.

```APIDOC
## nameprep

### Description
Prepares a string with the Nameprep profile of the stringprep algorithm. Nameprep is defined in RFC 3491.

### Signature
```rust
pub fn nameprep(s: &str) -> Result<Cow<'_, str>, Error>
```

### Parameters
* `s` (*str*) - The input string to prepare.

### Returns
* `Result<Cow<'_, str>, Error>` - A `Result` containing the prepared string as a `Cow<'_, str>` on success, or an `Error` on failure.
```

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

### x520prep

Source: https://docs.rs/stringprep/0.1.5/stringprep/index.html

Prepares a string according to the procedures described in Section 7 of ITU-T Recommendation X.520 (2019).

```APIDOC
## Function: x520prep

### Description
Prepares a string according to the procedures described in Section 7 of ITU-T Recommendation X.520 (2019).

### Signature
```rust
fn x520prep(s: &str) -> Result<String, Error>
```

### Parameters
* `s` (*&str*) - The input string to prepare.

### Returns
* `Result<String, Error>` - A `Result` containing the prepared string or an `Error` if the operation fails.
```

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

### x520prep

Source: https://docs.rs/stringprep/0.1.5/index.html

Prepares a string according to the procedures described in Section 7 of ITU-T Recommendation X.520 (2019).

```APIDOC
## x520prep

### Description
Prepares a string according to the procedures described in Section 7 of ITU-T Recommendation X.520 (2019).

### Function Signature
```rust
fn x520prep(input: &str) -> Result<String, Error>
```

### Parameters
* `input` (*str*) - The string to prepare.

### Returns
A `Result` containing the prepared string or an `Error` if the preparation fails.
```

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

### nodeprep

Source: https://docs.rs/stringprep/0.1.5/stringprep/fn.nodeprep.html

Prepares a string with the Nodeprep profile of the stringprep algorithm.

```APIDOC
## Function nodeprep

### Description
Prepares a string with the Nodeprep profile of the stringprep algorithm. Nameprep is defined in RFC 3920, Appendix A.

### Signature
```rust
pub fn nodeprep(s: &str) -> Result<Cow<'_, str>, Error>
```

### Parameters
* `s` (*str*) - The input string to prepare.

### Returns
* `Result<Cow<'_, str>, Error>` - A `Result` containing the prepared string as a `Cow<'_, str>` on success, or an `Error` on failure.
```

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

### Resourceprep Profile Implementation

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Implements the Resourceprep profile of the stringprep algorithm. It handles mapping, normalization, and checks for prohibited characters. Use this for preparing strings for JID resources in XMPP.

```rust
pub fn resourceprep(s: &str) -> Result<Cow<'_, str>, Error> {
    // fast path for ascii text
    if s.chars().all(|c| matches!(c, ' '..='~')) {
        return Ok(Cow::Borrowed(s));
    }

    // B.3. Mapping
    let mapped = s
        .chars()
        .filter(|&c| !tables::commonly_mapped_to_nothing(c))
        .collect::<String>();

    // B.4. Normalization
    let normalized = mapped.nfkc().collect::<String>();

    // B.5. Prohibited Output
    let prohibited = normalized.chars().find(|&c| {
        tables::non_ascii_space_character(c) /* C.1.2 */ ||
            tables::ascii_control_character(c) /* C.2.1 */ ||
            tables::non_ascii_control_character(c) /* C.2.2 */ ||

```

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

### x520prep

Source: https://docs.rs/stringprep/0.1.5/stringprep/fn.x520prep.html

Prepares a string according to Section 7 of ITU-T Recommendation X.520 (2019). Note that this function does not remove leading, trailing, or inner spaces as described in Section 7.6.

```APIDOC
## Function x520prep

### Description
Prepares a string according to the procedures described in Section 7 of ITU-T Recommendation X.520 (2019). Note that this function does _not_ remove leading, trailing, or inner spaces as described in Section 7.6, because the characters needing removal will vary across the matching rules and ASN.1 syntaxes used.

### Signature
```rust
pub fn x520prep(s: &str, case_fold: bool) -> Result<Cow<'_, str>, Error>
```

### Parameters
* `s` (`&str`): The input string to prepare.
* `case_fold` (`bool`): A boolean indicating whether to perform case folding.

### Returns
* `Result<Cow<'_, str>, Error>`: A `Cow<'_, str>` containing the prepared string on success, or an `Error` on failure.
```

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

### x520prep Function Usage

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Demonstrates the usage of the x520prep function for string preparation, including handling of Unicode characters and case conversion. Ensure correct Unicode normalization and case folding are applied.

```rust
assert_eq!(
            x520prep("J.  W.  wuz h\u{0115}re", true).unwrap(),
            "j.  w.  wuz h\u{0115}re"
        );
        assert_eq!(x520prep("J.\u{FE00} \u{9}W. \u{B}wuz h\u{0115}re", true).unwrap(), "j.  w.  wuz h\u{0115}re");
        assert_eq!(x520prep("UPPERCASED", true).unwrap(), "uppercased");
        assert_starts_with_combining_char(x520prep("\u{0306}hello", true));
```

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

### take

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Method
`take`

### Parameters
- **n** (usize) - The maximum number of elements to yield.
```

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

### by_ref

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Creates a reference adapter for an iterator.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Iterator`.

### Method
`by_ref`
```

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

### x520prep

Source: https://docs.rs/stringprep/0.1.5/stringprep/all.html

Performs the X520prep profile for X.520 preparation.

```APIDOC
## x520prep

### Description
Performs the X520prep profile for X.520 preparation.

### Function Signature
`fn x520prep(input: &str) -> Result<String, Error>`
```

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

### Nameprep Profile Implementation

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Implements the Nameprep profile of the stringprep algorithm. It handles mapping, normalization, and checks for prohibited characters and bidirectional text. Use this for preparing strings for use in protocols like XMPP.

```rust
pub fn nameprep(s: &str) -> Result<Cow<'_, str>, Error> {
    // fast path for common ascii text
    if s.chars().all(|c| matches!(c, '['..='~'])) {
        return Ok(Cow::Borrowed(s));
    }

    // 3. Mapping
    let mapped = s
        .chars()
        .filter(|&c| !tables::commonly_mapped_to_nothing(c))
        .flat_map(tables::case_fold_for_nfkc);

    // 4. Normalization
    let normalized = mapped.nfkc().collect::<String>();

    // 5. Prohibited Output
    let prohibited = normalized.chars().find(|&c| {
        tables::non_ascii_space_character(c) /* C.1.2 */ ||
            tables::non_ascii_control_character(c) /* C.2.2 */ ||
            tables::private_use(c) /* C.3 */ ||
            tables::non_character_code_point(c) /* C.4 */ ||
            tables::surrogate_code(c) /* C.5 */ ||
            tables::inappropriate_for_plain_text(c) /* C.6 */ ||
            tables::inappropriate_for_canonical_representation(c) /* C.7 */ ||
            tables::change_display_properties_or_deprecated(c) /* C.9 */ ||
            tables::tagging_character(c) /* C.9 */
    });
    if let Some(c) = prohibited {
        return Err(Error(ErrorCause::ProhibitedCharacter(c)));
    }

    // 6. Bidirectional Characters
    if is_prohibited_bidirectional_text(&normalized) {
        return Err(Error(ErrorCause::ProhibitedBidirectionalText));
    }

    // 7 Unassigned Code Points
    let unassigned = normalized
        .chars()
        .find(|&c| tables::unassigned_code_point(c));
    if let Some(c) = unassigned {
        return Err(Error(ErrorCause::ProhibitedCharacter(c)));
    }

    Ok(Cow::Owned(normalized))
}
```

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

### Nodeprep Profile Implementation

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Implements the Nodeprep profile for JID node names. It includes mapping, normalization, and checks for prohibited characters, including specific node characters. Use this for preparing strings for JID nodes in XMPP.

```rust
pub fn nodeprep(s: &str) -> Result<Cow<'_, str>, Error> {
    // fast path for common ascii text
    if s.chars()
        .all(|c| matches!(c, '['..='~' | '0'..='9' | '('..='.' | '#'..='%'))
    {
        return Ok(Cow::Borrowed(s));
    }

    // A.3. Mapping
    let mapped = s
        .chars()
        .filter(|&c| !tables::commonly_mapped_to_nothing(c))
        .flat_map(tables::case_fold_for_nfkc);

    // A.4. Normalization
    let normalized = mapped.nfkc().collect::<String>();

    // A.5. Prohibited Output
    let prohibited = normalized.chars().find(|&c| {
        tables::ascii_space_character(c) /* C.1.1 */ ||
            tables::non_ascii_space_character(c) /* C.1.2 */ ||
            tables::ascii_control_character(c) /* C.2.1 */ ||
            tables::non_ascii_control_character(c) /* C.2.2 */ ||
            tables::private_use(c) /* C.3 */ ||
            tables::non_character_code_point(c) /* C.4 */ ||
            tables::surrogate_code(c) /* C.5 */ ||
            tables::inappropriate_for_plain_text(c) /* C.6 */ ||
            tables::inappropriate_for_canonical_representation(c) /* C.7 */ ||
            tables::change_display_properties_or_deprecated(c) /* C.9 */ ||
            tables::tagging_character(c) /* C.9 */ ||
            prohibited_node_character(c)
    });
    if let Some(c) = prohibited {
        return Err(Error(ErrorCause::ProhibitedCharacter(c)));
    }

    // A.6. Bidirectional Characters
    if is_prohibited_bidirectional_text(&normalized) {
        return Err(Error(ErrorCause::ProhibitedBidirectionalText));
    }

    let unassigned = normalized
        .chars()
        .find(|&c| tables::unassigned_code_point(c));
    if let Some(c) = unassigned {
        return Err(Error(ErrorCause::ProhibitedCharacter(c)));
    }

    Ok(Cow::Owned(normalized))
}
```

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

### x520prep Function

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Prepares a string according to Section 7 of ITU-T Recommendation X.520 (2019). This function handles mapping, normalization (NFKC), and prohibition of specific characters. It does not remove leading, trailing, or inner spaces.

```APIDOC
## x520prep(s: &str, case_fold: bool) -> Result<Cow<'_, str>, Error>

### Description
Prepares a string according to the procedures described in Section 7 of [ITU-T Recommendation X.520 (2019)](https://www.itu.int/rec/T-REC-X.520-201910-I/en).

Note that this function does _not_ remove leading, trailing, or inner spaces as described in Section 7.6, because the characters needing removal will vary across the matching rules and ASN.1 syntaxes used.

### Parameters
- **s** (*&str*) - The input string to prepare.
- **case_fold** (*bool*) - If true, performs case folding as part of normalization.

### Returns
- `Result<Cow<'_, str>, Error>` - On success, returns a `Cow` containing the prepared string. On failure, returns an `Error`.

### Errors
- `Error(ErrorCause::EmptyString)` - If the input string is empty.
- `Error(ErrorCause::ProhibitedCharacter(char))` - If a prohibited character is found.
- `Error(ErrorCause::StartsWithCombiningCharacter)` - If the string starts with a combining character.

### Examples
```rust
use stringprep::x520prep;

// Example 1: Basic usage with case folding
let result1 = x520prep("foo@bar", true);
match result1 {
    Ok(prepared_string) => println!("Prepared: {}", prepared_string),
    Err(e) => eprintln!("Error: {:?}", e),
}

// Example 2: Usage without case folding, with special characters
let result2 = x520prep("J.\u{FE00} \u{9}W. \u{B}wuz h\u{0115}re", false);
match result2 {
    Ok(prepared_string) => println!("Prepared: {}", prepared_string),
    Err(e) => eprintln!("Error: {:?}", e),
}
```
```

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

### map_windows

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Calls a function for each contiguous window of size `N` and returns an iterator over the results. This is a nightly-only experimental API.

```APIDOC
## fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

### Description
Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well.

### Method
`map_windows`

### Parameters
- **f** (F) - A closure that takes a slice of `N` elements and returns a value `R`.

### Constraints
This is a nightly-only experimental API. (`iter_map_windows`)
```

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

### partition

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Consumes an iterator and creates two collections based on a predicate.

```APIDOC
## fn partition<B, F>(self, f: F) -> (B, B)

### Description
Consumes an iterator, creating two collections from it.

### Method
`partition`

### Parameters
- **f** (F) - A closure that takes a reference to an item and returns a boolean.

### Type Parameters
- **B**: Must implement `Default` and `Extend<Self::Item>`.
```

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

### SASLprep String Preparation

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Prepares a string using the SASLprep profile. Handles character mapping, normalization, and checks for prohibited characters and bidirectional text. Includes a fast path for ASCII text.

```rust
pub fn saslprep(s: &str) -> Result<Cow<'_, str>, Error> {
    // fast path for ascii text
    if s.chars()
        .all(|c| c.is_ascii() && !tables::ascii_control_character(c)) {
        return Ok(Cow::Borrowed(s));
    }

    // 2.1 Mapping
    let mapped = s
        .chars()
        .map(|c| {
            if tables::non_ascii_space_character(c) {
                ' '
            } else {
                c
            }
        })
        .filter(|&c| !tables::commonly_mapped_to_nothing(c));

    // 2.2 Normalization
    let normalized = mapped.nfkc().collect::<String>();

    // 2.3 Prohibited Output
    let prohibited = normalized.chars().find(|&c| {
        tables::non_ascii_space_character(c) /* C.1.2 */ ||
            tables::ascii_control_character(c) /* C.2.1 */ ||
            tables::non_ascii_control_character(c) /* C.2.2 */ ||
            tables::private_use(c) /* C.3 */ ||
            tables::non_character_code_point(c) /* C.4 */ ||
            tables::surrogate_code(c) /* C.5 */ ||
            tables::inappropriate_for_plain_text(c) /* C.6 */ ||
            tables::inappropriate_for_canonical_representation(c) /* C.7 */ ||
            tables::change_display_properties_or_deprecated(c) /* C.8 */ ||
            tables::tagging_character(c) /* C.9 */
    });
    if let Some(c) = prohibited {
        return Err(Error(ErrorCause::ProhibitedCharacter(c)));
    }

    // 2.4. Bidirectional Characters
    if is_prohibited_bidirectional_text(&normalized) {
        return Err(Error(ErrorCause::ProhibitedBidirectionalText));
    }

    // 2.5 Unassigned Code Points
    let unassigned = normalized
        .chars()
        .find(|&c| tables::unassigned_code_point(c));
    if let Some(c) = unassigned {
        return Err(Error(ErrorCause::ProhibitedCharacter(c)));
    }

    Ok(Cow::Owned(normalized))
}
```

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

### product

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Iterates over the entire iterator, multiplying all the elements.

```APIDOC
## fn product<P>(self) -> P

### Description
Iterates over the entire iterator, multiplying all the elements.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `P`: The product of the elements.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### Resourceprep Profile

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

The Resourceprep profile is used for preparing strings for use as resource identifiers in XMPP (Jabber). It is a simpler profile focusing on ASCII characters and basic normalization.

```APIDOC
## Resourceprep Profile

### Description
Prepares a string with the Resourceprep profile of the stringprep algorithm, as defined in [RFC 3920, Appendix B][]. This profile is used for preparing strings for use as resource identifiers in XMPP (Jabber).

[RFC 3920, Appendix B]: https://tools.ietf.org/html/rfc3920#appendix-B

### Function Signature
`pub fn resourceprep(s: &str) -> Result<Cow<'_, str>, Error>`

### Steps:
1. **Mapping**: Removes characters mapped to nothing.
2. **Normalization**: Normalizes the string using NFKC.
3. **Prohibited Output**: Checks for and rejects characters that are prohibited according to the stringprep specification (e.g., non-ASCII spaces, control characters).

### Returns
- `Ok(Cow<'_, str>)`: The prepared string if successful.
- `Err(Error)`: An error if the string contains prohibited characters.
```

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

### nodeprep

Source: https://docs.rs/stringprep/0.1.5/stringprep/all.html

Performs the Nodprep profile for internationalized domain names.

```APIDOC
## nodeprep

### Description
Performs the Nodprep profile for internationalized domain names.

### Function Signature
`fn nodeprep(input: &str) -> Result<String, Error>`
```

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

### resourceprep

Source: https://docs.rs/stringprep/0.1.5/stringprep/all.html

Performs the Resourceprep profile for internationalized resource identifiers.

```APIDOC
## resourceprep

### Description
Performs the Resourceprep profile for internationalized resource identifiers.

### Function Signature
`fn resourceprep(input: &str) -> Result<String, Error>`
```

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

### saslprep Function

Source: https://docs.rs/stringprep/0.1.5/stringprep/fn.saslprep.html

Prepares a string using the SASLprep profile of the stringprep algorithm as defined in RFC 4013.

```APIDOC
## Function saslprep

### Description
Prepares a string with the SASLprep profile of the stringprep algorithm. SASLprep is defined in RFC 4013.

### Signature
```rust
pub fn saslprep(s: &str) -> Result<Cow<'_, str>, Error>
```

### Parameters
* **s** (*&str*) - The input string to prepare.

### Returns
* `Result<Cow<'_, str>, Error>` - A `Result` containing either the prepared string as a `Cow<'_, str>` on success, or an `Error` on failure.
```

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

### nameprep

Source: https://docs.rs/stringprep/0.1.5/stringprep/all.html

Performs the Nameprep profile for internationalized domain names.

```APIDOC
## nameprep

### Description
Performs the Nameprep profile for internationalized domain names.

### Function Signature
`fn nameprep(input: &str) -> Result<String, Error>`
```

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

### any

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Tests if any element of the iterator matches a predicate.

```APIDOC
## fn any<F>(&mut self, f: F) -> bool

### Description
Tests if any element of the iterator matches a predicate.

### Method
`any`

### Parameters
- **f** (F) - A closure that takes an item and returns a boolean.
```

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

### fold

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Folds every element into an accumulator by applying an operation, returning the final result.

```APIDOC
## fn fold<B, F>(self, init: B, f: F) -> B

### Description
Folds every element into an accumulator by applying an operation, returning the final result.

### Method
`fold`

### Parameters
- **init** (B) - The initial value for the accumulator.
- **f** (F) - A closure that takes the accumulator and the next item, returning the updated accumulator.
```

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

### cloned

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Creates an iterator which `clone`s all of its elements.

```APIDOC
## fn cloned<'a, T>(self) -> Cloned<Self>

### Description
Creates an iterator which `clone`s all of its elements.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `Cloned<Self>`: An iterator that yields cloned elements.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### Nameprep Profile

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

The Nameprep profile is used for preparing strings for use as internationalized domain names (IDNs). It involves mapping, normalization, and checks for prohibited characters and bidirectional text.

```APIDOC
## Nameprep Profile

### Description
Prepares a string with the Nameprep profile of the stringprep algorithm, as defined in [RFC 3920, Appendix A][]. This profile is commonly used for internationalized domain names.

[RFC 3920, Appendix A]: https://tools.ietf.org/html/rfc3920#appendix-A

### Function Signature
`pub fn nameprep(s: &str) -> Result<Cow<'_, str>, Error>`

### Steps:
1. **Mapping**: Applies case folding and removes characters mapped to nothing.
2. **Normalization**: Normalizes the string using NFKC.
3. **Prohibited Output**: Checks for and rejects characters that are prohibited according to the stringprep specification (e.g., non-ASCII spaces, control characters, private use, surrogates, inappropriate characters).
4. **Bidirectional Characters**: Checks for prohibited bidirectional text.
5. **Unassigned Code Points**: Checks for and rejects unassigned code points.

### Returns
- `Ok(Cow<'_, str>)`: The prepared string if successful.
- `Err(Error)`: An error if the string contains prohibited characters or bidirectional text.
```

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

### partial_cmp_by

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

```APIDOC
## fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

### Description
Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `Option<Ordering>`: The result of the partial lexicographical comparison using the provided function, or None if elements are incomparable.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### CaseFoldForNfkc Iterator Methods

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

This section details the methods available on the CaseFoldForNfkc struct when implemented as an Iterator. These methods allow for iteration, manipulation, and inspection of the character sequence.

```APIDOC
## Iterator for CaseFoldForNfkc

### Description
Provides methods for iterating over characters for case folding according to NFKC normalization.

### Methods

- **`next(&mut self) -> Option<char>`**: Advances the iterator and returns the next character.
- **`next_chunk<const N: usize>(&mut self) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>`**: Advances the iterator and returns an array of the next `N` characters. (Nightly-only)
- **`size_hint(&self) -> (usize, Option<usize>)`**: Returns the bounds on the remaining length of the iterator.
- **`count(self) -> usize`**: Consumes the iterator and returns the total number of characters.
- **`last(self) -> Option<Self::Item>`**: Consumes the iterator and returns the last character.
- **`advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>`**: Advances the iterator by `n` elements. (Nightly-only)
- **`nth(&mut self, n: usize) -> Option<Self::Item>`**: Returns the `n`th character of the iterator.
- **`step_by(self, step: usize) -> StepBy<Self>`**: Creates an iterator that steps by a given amount.
- **`chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>`**: Chains this iterator with another iterator.
- **`zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>`**: Zips this iterator with another iterator into pairs.
- **`intersperse(self, separator: Self::Item) -> Intersperse<Self>`**: Places a separator between adjacent items. (Nightly-only)
- **`intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>`**: Places an item generated by a closure between adjacent items. (Nightly-only)
- **`map<B, F>(self, f: F) -> Map<Self, F>`**: Maps each character to a new value using a closure.
- **`for_each<F>(self, f: F)`**: Executes a closure on each character.
- **`filter<P>(self, predicate: P) -> Filter<Self, P>`**: Filters characters based on a predicate closure.
- **`filter_map<B, F>(self, f: F) -> FilterMap<Self, F>`**: Filters and maps characters using a closure.
- **`enumerate(self) -> Enumerate<Self>`**: Creates an iterator that yields the index along with each character.
- **`peekable(self) -> Peekable<Self>`**: Creates a peekable iterator.
- **`skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>`**: Skips characters while a predicate is true.
- **`take_while<P>(self, predicate: P) -> TakeWhile<Self, P>`**: Yields characters while a predicate is true.
- **`map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>`**: Yields and maps characters while a predicate is true.
- **`skip(self, n: usize) -> Skip<Self>`**: Skips the first `n` characters.
```

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

### try_reduce

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Reduces elements to a single value with a fallible operation, short-circuiting on error. This is a nightly-only experimental API.

```APIDOC
## fn try_reduce<R>(&mut self, f: impl FnMut(Self::Item, Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

### Description
Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

### Method
`try_reduce`

### Parameters
- **f** (impl FnMut(Self::Item, Self::Item) -> R) - A closure that takes two items and returns a `Try` type.

### Constraints
- `R` must implement `Try<Output = Self::Item>`.
- `<R as Try>::Residual` must implement `Residual<Option<Self::Item>>`.
- This is a nightly-only experimental API. (`iterator_try_reduce`)
```

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

### Nodeprep Profile

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

The Nodeprep profile is used for preparing strings for use as node identifiers in XMPP (Jabber). It is similar to Nameprep but includes additional checks for characters not allowed in JID nodes.

```APIDOC
## Nodeprep Profile

### Description
Prepares a string with the Nodeprep profile of the stringprep algorithm. This profile is used for preparing strings for use as node identifiers in XMPP (Jabber), as defined in [RFC 3920, Appendix A][].

[RFC 3920, Appendix A]: https://tools.ietf.org/html/rfc3920#appendix-A

### Function Signature
`pub fn nodeprep(s: &str) -> Result<Cow<'_, str>, Error>`

### Steps:
1. **Mapping**: Applies case folding and removes characters mapped to nothing.
2. **Normalization**: Normalizes the string using NFKC.
3. **Prohibited Output**: Checks for and rejects characters that are prohibited according to the stringprep specification and additional characters not allowed in JID nodes (e.g., `"`, `&`, `'`, `/`, `:`, `<`, `>`, `@`).
4. **Bidirectional Characters**: Checks for prohibited bidirectional text.
5. **Unassigned Code Points**: Checks for and rejects unassigned code points.

### Returns
- `Ok(Cow<'_, str>)`: The prepared string if successful.
- `Err(Error)`: An error if the string contains prohibited characters or bidirectional text.
```

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

### Check for Commonly Mapped to Nothing Characters

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/tables.rs.html

Identifies characters that are commonly mapped to nothing in string preparation processes. Uses a `matches!` macro for efficient checking against a list of Unicode characters.

```rust
pub fn commonly_mapped_to_nothing(c: char) -> bool {
    matches!(
        c,
        '\u{00AD}'
            | '\u{034F}'
            | '\u{1806}'
            | '\u{180B}'
            | '\u{180C}'
            | '\u{180D}'
            | '\u{200B}'
            | '\u{200C}'
            | '\u{200D}'
            | '\u{2060}'
            | '\u{FE00}'
            | '\u{FE01}'
            | '\u{FE02}'
            | '\u{FE03}'
            | '\u{FE04}'
            | '\u{FE05}'
            | '\u{FE06}'
            | '\u{FE07}'
            | '\u{FE08}'
            | '\u{FE09}'
            | '\u{FE0A}'
            | '\u{FE0B}'
            | '\u{FE0C}'
            | '\u{FE0D}'
            | '\u{FE0E}'
            | '\u{FE0F}'
            | '\u{FEFF}'
    )
}
```

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

### scan

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

An iterator adapter which holds internal state and produces a new iterator.

```APIDOC
## fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

### Description
An iterator adapter which, like `fold`, holds internal state, but unlike `fold`, produces a new iterator.

### Method
`scan`

### Parameters
- **initial_state** (St) - The initial state for the adapter.
- **f** (F) - A closure that takes a mutable reference to the state and the next item, returning `Option<B>`.
```

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

### copied

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Creates an iterator which copies all of its elements.

```APIDOC
## fn copied<'a, T>(self) -> Copied<Self>

### Description
Creates an iterator which copies all of its elements.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `Copied<Self>`: An iterator that yields copied elements.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### inspect

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Performs an action for each element of an iterator without consuming it.

```APIDOC
## fn inspect<F>(self, f: F) -> Inspect<Self, F>

### Description
Does something with each element of an iterator, passing the value on.

### Method
`inspect`

### Parameters
- **f** (F) - A closure that takes a reference to the iterator item.
```

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

### min_by_key

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Returns the element that gives the minimum value from the specified function.

```APIDOC
## fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

### Description
Returns the element that gives the minimum value from the specified function.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `Option<Self::Item>`: The element with the minimum key value or None.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### try_for_each

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Applies a fallible function to each item, stopping at the first error. This is a nightly-only experimental API.

```APIDOC
## fn try_for_each<F, R>(&mut self, f: F) -> R

### Description
An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

### Method
`try_for_each`

### Parameters
- **f** (F) - A closure that takes an item and returns a `Try` type.

### Type Parameters
- **R**: Must implement `Try<Output = ()>`.
```

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

### cmp_by

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

```APIDOC
## fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

### Description
Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `Ordering`: The result of the lexicographical comparison using the provided function.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### ASCII Optimizations Test

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/lib.rs.html

Tests for ASCII optimizations in nodeprep, nameprep, and resourceprep functions. These optimizations should result in an owned String when the input is purely ASCII.

```rust
if let Cow::Owned(_) = nodeprep("nodepart").unwrap() {
            panic!("\u201cnodepart\u201d should get optimised as ASCII");
        }
        if let Cow::Owned(_) = nameprep("domainpart.example").unwrap() {
            panic!("\u201cdomainpart.example\u201d should get optimised as ASCII");
        }
        if let Cow::Owned(_) = resourceprep("resourcepart").unwrap() {
            panic!("\u201cresourcepart\u201d should get optimised as ASCII");
        }
```

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

### min

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Returns the minimum element of an iterator.

```APIDOC
## fn min(self) -> Option<Self::Item>

### Description
Returns the minimum element of an iterator.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `Option<Self::Item>`: The minimum element or None.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### is_partitioned

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Checks if an iterator's elements are partitioned according to a predicate. This is a nightly-only experimental API.

```APIDOC
## fn is_partitioned<P>(self, predicate: P) -> bool

### Description
Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return `true` precede all those that return `false`.

### Method
`is_partitioned`

### Parameters
- **predicate** (P) - A closure that takes an item and returns a boolean.

### Constraints
This is a nightly-only experimental API. (`iter_is_partitioned`)
```

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

### unzip

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Converts an iterator of pairs into a pair of containers.

```APIDOC
## fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

### Description
Converts an iterator of pairs into a pair of containers.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `(FromA, FromB)`: A tuple containing two containers, each populated with elements from the corresponding position in the input pairs.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### try_fold

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Applies a fallible function to each item, accumulating a result, and short-circuiting on error.

```APIDOC
## fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

### Description
An iterator method that applies a function as long as it returns successfully, producing a single, final value.

### Method
`try_fold`

### Parameters
- **init** (B) - The initial value for the accumulator.
- **f** (F) - A closure that takes the accumulator and the next item, returning a `Try` type.

### Type Parameters
- **R**: Must implement `Try<Output = B>`.
```

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

### partial_cmp

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Lexicographically compares the `PartialOrd` elements of this `Iterator` with those of another. The comparison works like short-circuit evaluation.

```APIDOC
## fn partial_cmp<I>(self, other: I) -> Option<Ordering>

### Description
Lexicographically compares the `PartialOrd` elements of this `Iterator` with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `Option<Ordering>`: The result of the partial lexicographical comparison, or None if elements are incomparable.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### all

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Tests if every element of the iterator matches a predicate.

```APIDOC
## fn all<F>(&mut self, f: F) -> bool

### Description
Tests if every element of the iterator matches a predicate.

### Method
`all`

### Parameters
- **f** (F) - A closure that takes an item and returns a boolean.
```

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

### collect

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Transforms an iterator into a collection.

```APIDOC
## fn collect<B>(self) -> B

### Description
Transforms an iterator into a collection.

### Method
`collect`

### Type Parameters
- **B**: Must implement `FromIterator<Self::Item>`.
```

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

### try_collect

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Fallibly transforms an iterator into a collection, short-circuiting on failure. This is a nightly-only experimental API.

```APIDOC
## fn try_collect<B>(&mut self) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

### Description
Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

### Method
`try_collect`

### Type Parameters
- **B**: Must implement `FromIterator<<Self::Item as Try>::Output>`.

### Constraints
- `Self::Item` must implement `Try`.
- `<Self::Item as Try>::Residual` must implement `Residual<B>`.
- This is a nightly-only experimental API. (`iterator_try_collect`)
```

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

### fuse

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Creates an iterator which ends after the first `None` is encountered.

```APIDOC
## fn fuse(self) -> Fuse<Self>

### Description
Creates an iterator which ends after the first `None`.

### Method
`fuse`
```

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

### try_find

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Applies a function to the elements of an iterator and returns the first true result or the first error. This is a nightly-only experimental API.

```APIDOC
## fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

### Description
Applies function to the elements of iterator and returns the first true result or the first error. This is a nightly-only experimental API.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
// Example usage not provided in source
```

### Response
#### Success Response (200)
- `<<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType`: The result of the operation.

#### Response Example
```json
// Example usage not provided in source
```
```

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

### cjk_compat_variants

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Applies a transformation to replace CJK Compatibility Ideograph codepoints with normal forms using Standardized Variation Sequences. This is useful for normalizing text while preserving the original intent.

```APIDOC
## fn cjk_compat_variants(self) -> Replacements<I>

### Description
A transformation which replaces CJK Compatibility Ideograph codepoints with normal forms using Standardized Variation Sequences. This is not part of the canonical or compatibility decomposition algorithms, but performing it before those algorithms produces normalized output which better preserves the intent of the original text.

### Method
`cjk_compat_variants`

### Parameters
None
```

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

### saslprep

Source: https://docs.rs/stringprep/0.1.5/stringprep/all.html

Performs the SASLprep profile for authentication.

```APIDOC
## saslprep

### Description
Performs the SASLprep profile for authentication.

### Function Signature
`fn saslprep(input: &str) -> Result<String, Error>`
```

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

### collect_into

Source: https://docs.rs/stringprep/0.1.5/stringprep/tables/struct.CaseFoldForNfkc.html

Collects all items from an iterator into a mutable collection. This is a nightly-only experimental API.

```APIDOC
## fn collect_into<E>(self, collection: &mut E) -> &mut E

### Description
Collects all the items from an iterator into a collection.

### Method
`collect_into`

### Parameters
- **collection** (&mut E) - A mutable reference to the collection to extend.

### Type Parameters
- **E**: Must implement `Extend<Self::Item>`.

### Constraints
This is a nightly-only experimental API. (`iter_collect_into`)
```

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

### Check for Tagging Characters

Source: https://docs.rs/stringprep/0.1.5/src/stringprep/tables.rs.html

Identifies tagging characters used in stringprep.

```rust
pub fn tagging_character(c: char) -> bool {
    matches!(c, '\u{E0001}' | '\u{E0020}'..='\u{E007F}')
}
```
Tokens:
Raw