ASS-RS Core

https://docs.rs/ass-core/latest/
Admin
ASS-RS Core is a high-performance, memory-efficient parser, analyzer, and manipulator for the ASS...
Tokens:907,974
Snippets:6,142
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Rust Ecosystem Links

Source: https://docs.rs/ass-core/latest/ass_core/plugin/tags/karaoke/index

Provides links to essential Rust documentation and resources, including the Rust website, The Book, Standard Library API Reference, Rust by Example, The Cargo Guide, and Clippy Documentation.

```rust
Rust Resources:
  - Rust website: https://www.rust-lang.org/
  - The Book: https://doc.rust-lang.org/book/
  - Standard Library API Reference: https://doc.rust-lang.org/std/
  - Rust by Example: https://doc.rust-lang.org/rust-by-example/
  - The Cargo Guide: https://doc.rust-lang.org/cargo/guide/
  - Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### ASS Script Style Analysis Quick Start

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/styles/mod

Demonstrates how to parse an ASS script and perform style analysis using the StyleAnalyzer. It covers basic setup and usage for analyzing style definitions within a script.

```rust
use ass_core::analysis::styles::{StyleAnalyzer, ResolvedStyle};
use ass_core::parser::Script;

let script_text = r#"[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
"#;

let script = Script::parse(script_text)?;
let analyzer = StyleAnalyzer::new(&script);

```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-core/latest/src/ass_core/plugin/sections/aegisub

Provides links to essential Rust documentation and resources, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, and Cargo Guide.

```rust
Rust Resources:
  Rust Website: https://www.rust-lang.org/
  The Book: https://doc.rust-lang.org/book/
  Standard Library API Reference: https://doc.rust-lang.org/std/
  Rust by Example: https://doc.rust-lang.org/rust-by-example/
  Cargo Guide: https://doc.rust-lang.org/cargo/guide/
  Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-core/latest/ass_core/parser/position_tracker/index

Provides links to essential Rust resources, including the official Rust website, The Book, standard library documentation, Rust by Example, the Cargo Guide, and Clippy documentation.

```rust
Rust Website: https://www.rust-lang.org/
The Book: https://doc.rust-lang.org/book/
Standard Library API Reference: https://doc.rust-lang.org/std/
Rust by Example: https://doc.rust-lang.org/rust-by-example/
The Cargo Guide: https://doc.rust-lang.org/cargo/guide/
Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### Example Usage of create_aegisub_processors

Source: https://docs.rs/ass-core/latest/ass_core/plugin/sections/aegisub/fn

Demonstrates how to use the `create_aegisub_processors` function to obtain Aegisub section processors and register them with an `ExtensionRegistry`. This example shows a common pattern for plugin initialization.

```rust
use ass_core::plugin::{ExtensionRegistry, sections::aegisub::create_aegisub_processors};

let mut registry = ExtensionRegistry::new();
for processor in create_aegisub_processors() {
    registry.register_section_processor(processor).unwrap();
}
```

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

### Rust Documentation Resources

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/main

Provides links to essential Rust documentation resources, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, The Cargo Guide, and Clippy Documentation. These resources are invaluable for learning and using Rust effectively.

```Rust
Rust Resources:
  - Rust website: https://www.rust-lang.org/
  - The Book: https://doc.rust-lang.org/book/
  - Standard Library API Reference: https://doc.rust-lang.org/std/
  - Rust by Example: https://doc.rust-lang.org/rust-by-example/
  - The Cargo Guide: https://doc.rust-lang.org/cargo/guide/
  - Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/linting/rules/encoding

Provides links to essential Rust documentation and resources, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, The Cargo Guide, and Clippy Documentation.

```rust
Rust Website: https://www.rust-lang.org/
The Book: https://doc.rust-lang.org/book/
Standard Library API Reference: https://doc.rust-lang.org/std/
Rust by Example: https://doc.rust-lang.org/rust-by-example/
The Cargo Guide: https://doc.rust-lang.org/cargo/guide/
Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### Rust Standard Library Resources

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/position_tracker

Provides links to essential resources for Rust developers, including the official Rust website, The Book, the Standard Library API Reference, Rust by Example, the Cargo Guide, and Clippy documentation.

```Rust
Rust Resources:
  Website: https://www.rust-lang.org/
  The Book: https://doc.rust-lang.org/book/
  Standard Library API Reference: https://doc.rust-lang.org/std/
  Rust by Example: https://doc.rust-lang.org/rust-by-example/
  Cargo Guide: https://doc.rust-lang.org/cargo/guide/
  Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### ScriptInfoParser::new - Constructor

Source: https://docs.rs/ass-core/latest/ass_core/parser/sections/script_info/struct

Creates a new instance of ScriptInfoParser. This function initializes the parser with the source text, starting position, and starting line number.

```APIDOC
ScriptInfoParser::new(source: &'a str, start_position: usize, start_line: usize) -> Self

Description:
  Create new script info parser for source text.

Parameters:
  - source: The source text to parse.
  - start_position: The starting byte position within the source text.
  - start_line: The starting line number.

Returns:
  A new instance of ScriptInfoParser.
```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-core/latest/src/ass_core/plugin/tags/font

Provides links to essential resources within the Rust ecosystem, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, the Cargo Guide, and Clippy documentation.

```Rust
Rust Ecosystem:
  - Rust Website: https://www.rust-lang.org/
  - The Book: https://doc.rust-lang.org/book/
  - Standard Library API Reference: https://doc.rust-lang.org/std/
  - Rust by Example: https://doc.rust-lang.org/rust-by-example/
  - Cargo Guide: https://doc.rust-lang.org/cargo/guide/
  - Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### Initialize ass-core Parser

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/sections/events

Creates a new instance of the ass-core parser. It takes the source string, starting position, and starting line number as input to initialize the internal position tracker and issue list. The format is initially set to `None`.

```rust
pub fn new(source: &'a str, start_position: usize, start_line: usize) -> Self {
    Self {
        tracker: PositionTracker::new_at(
            source,
            start_position,
            u32::try_from(start_line).unwrap_or(u32::MAX),
            1,
        ),
        issues: Vec::new(),
        format: None,
    }
}
```

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

### Streaming Parser Example

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/streaming

Demonstrates how to use the `StreamingParser` to process ASS script content incrementally by feeding chunks of data. It shows the process of initializing the parser, feeding multiple chunks, and finishing the parsing to get the final result.

```rust
use ass_core::parser::streaming::StreamingParser;

let mut parser = StreamingParser::new();

// Process chunks incrementally
let chunk1 = b"[Script Info]\nTitle: Example\n";
let deltas1 = parser.feed_chunk(chunk1)?;

let chunk2 = b"[Events]\nFormat: Layer, Start, End\n";
let deltas2 = parser.feed_chunk(chunk2)?;

let result = parser.finish()?;
# Ok::<(), Box<dyn std::error::Error>>(())
```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-core/latest/ass_core/analysis/events/scoring/index

Provides links to important resources within the Rust ecosystem, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, The Cargo Guide, and Clippy Documentation.

```rust
Rust Ecosystem:
  - Rust website: https://www.rust-lang.org/
  - The Book: https://doc.rust-lang.org/book/
  - Standard Library API Reference: https://doc.rust-lang.org/std/
  - Rust by Example: https://doc.rust-lang.org/rust-by-example/
  - The Cargo Guide: https://doc.rust-lang.org/cargo/guide/
  - Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### Example Usage of create_special_handlers

Source: https://docs.rs/ass-core/latest/ass_core/plugin/tags/special/fn

Demonstrates how to use the `create_special_handlers` function to obtain tag handlers and register them with an `ExtensionRegistry`. This example illustrates a common pattern for initializing plugin functionality.

```rust
use ass_core::plugin::{ExtensionRegistry, tags::special::create_special_handlers};

let mut registry = ExtensionRegistry::new();
for handler in create_special_handlers() {
    registry.register_tag_handler(handler).unwrap();
}
```

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

### ASS Tokenizer Example

Source: https://docs.rs/ass-core/latest/src/ass_core/tokenizer/mod

Demonstrates how to use the AssTokenizer to iterate over tokens in an ASS script. It initializes the tokenizer with a source string and processes each token, printing it to the console. This example highlights the zero-copy nature and incremental tokenization capabilities.

```rust
use ass_core::tokenizer::AssTokenizer;

let source = "[Script Info]\nTitle: Example";
let mut tokenizer = AssTokenizer::new(source);

while let Some(token) = tokenizer.next_token()? {
    println!("{:?}", token);
}
Ok::<(), Box<dyn std::error::Error>>(())
```

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

### Initialize Script Info Parser

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/sections/script_info

Creates a new instance of the script info parser with the provided source string, starting byte position, and starting line number. This is used to track the position within the source file during parsing.

```rust
pub fn new(source: &'a str, start_position: usize, start_line: usize) -> Self {
    Self {
        tracker: PositionTracker::new_at(
            source,
            start_position,
            u32::try_from(start_line).unwrap_or(u32::MAX),
            1,
        ),
        issues: Vec::new(),
    }
}
```

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

### Example: Registering Advanced Handlers

Source: https://docs.rs/ass-core/latest/src/ass_core/plugin/tags/advanced

Demonstrates how to create advanced tag handlers using `create_advanced_handlers` and register them with an `ExtensionRegistry`.

```rust
use ass_core::plugin::{ExtensionRegistry, tags::advanced::create_advanced_handlers};

let mut registry = ExtensionRegistry::new();
for handler in create_advanced_handlers() {
    registry.register_tag_handler(handler).unwrap();
}
```

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

### Create StylesParser

Source: https://docs.rs/ass-core/latest/ass_core/parser/sections/styles/struct

Initializes a new StylesParser with the source text and starting position/line number.

```rust
pub fn new<'a>(source: &'a str, start_position: usize, start_line: usize) -> Self
```

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

### Initialize StylesParser with Format

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/sections/styles

Creates a new `StylesParser` instance with a pre-defined format, suitable for incremental parsing. It takes the source text, format array, starting position, and starting line number.

```rust
pub fn with_format(
    source: &'a str,
    format: &[&'a str],
    start_position: usize,
    start_line: u32,
) -> Self {
    Self {
        tracker: PositionTracker::new_at(source, start_position, start_line, 1),
        issues: Vec::new(),
        format: Some(format.to_vec()),
    }
}
```

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

### ASS Tokenizer Example

Source: https://docs.rs/ass-core/latest/src/ass_core/tokenizer/tokens

Demonstrates how to use the `Token` and `TokenType` from the `ass_core::tokenizer` module to create a token representing a section header. This example highlights the zero-copy nature of tokens by using string slices that reference the original source text.

```rust
use ass_core::tokenizer::{Token, TokenType};

let source = "[Script Info]";
// Token would be created by tokenizer with span referencing source
let token = Token {
    token_type: TokenType::SectionHeader,
    span: &source[0..12], // "[Script Info"
    line: 1,
    column: 1,
};
```

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

### Initialize ass-core Parser with Format

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/sections/events

Creates a new parser instance with a pre-defined format, suitable for incremental parsing. This method takes the source string, a slice of format strings, the starting position, and the starting line number. The provided format is stored for use during parsing.

```rust
pub fn with_format(
    source: &'a str,
    format: &[&'a str],
    start_position: usize,
    start_line: u32,
) -> Self {
    Self {
        tracker: PositionTracker::new_at(source, start_position, start_line, 1),
        issues: Vec::new(),
        format: Some(format.to_vec()),
    }
}
```

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

### Get Remaining Source Text in ass-core

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/position_tracker

The `remaining` method returns a string slice representing the portion of the source text that has not yet been processed by the parser. It starts from the current offset to the end of the source.

```rust
/// Get remaining source text from current position
#[must_use]
pub fn remaining(&self) -> &'a str {
    &self.source[self.offset..]
}
```

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

### Quick Start: Parsing and Analyzing ASS Script

Source: https://docs.rs/ass-core/latest/ass_core

Demonstrates how to parse ASS script text into a Script object and perform analysis using the ass-core crate. It includes setting up the script text and utilizing the Script::parse and ScriptAnalysis::analyze functions.

```rust
use ass_core::{Script, analysis::ScriptAnalysis};

let script_text = r#"\
[Script Info]\nTitle: Example\nScriptType: v4.00+\n\n[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\nStyle: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1\n\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\nDialogue: 0,0:00:00.00,0:00:05.00,Default,,0,0,0,,Hello World!\n"#;

let script = Script::parse(script_text)?;
let analysis = ScriptAnalysis::analyze(&script)?;
```

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

### Quick Start: Parsing and Analyzing ASS Script

Source: https://docs.rs/ass-core/latest/index

Demonstrates how to parse ASS script text into a Script object and perform analysis using the ass-core crate. It includes setting up the script text and utilizing the Script::parse and ScriptAnalysis::analyze functions.

```rust
use ass_core::{Script, analysis::ScriptAnalysis};

let script_text = r#"\
[Script Info]\nTitle: Example\nScriptType: v4.00+\n\n[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\nStyle: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1\n\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\nDialogue: 0,0:00:00.00,0:00:05.00,Default,,0,0,0,,Hello World!\n"#;

let script = Script::parse(script_text)?;
let analysis = ScriptAnalysis::analyze(&script)?;
```

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

### ass-core Crate Overview

Source: https://docs.rs/ass-core/latest/ass_core/tokenizer/simd/index

Provides an overview of the ass-core crate, including its version, license, source code links, and dependencies. It also highlights the documentation coverage percentage.

```rust
Crate: ass-core
Version: 0.1.1
License: MIT
Dependencies:
  - ahash ^0.8.11
  - bitflags ^2.4.1
  - bumpalo ^3.14 (optional)
  - criterion ^0.5 (optional)
  - hashbrown ^0.14 (optional)
  - serde ^1.0 (optional)
  - thiserror ^1.0.63
  - wide ^0.7 (optional)
Documentation Coverage: 95.59%
```

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

### CoreError Usage Example

Source: https://docs.rs/ass-core/latest/ass_core/utils/errors/index

Demonstrates how to create and use `CoreError` instances, check their categories, and access suggestions for common error scenarios. This example highlights the structured error handling provided by the `ass_core::utils::errors` module.

```rust
use ass_core::utils::errors::{CoreError, Result, ErrorCategory};

// Create specific error types
let color_err = CoreError::invalid_color("invalid");
let time_err = CoreError::invalid_time("1:23", "missing seconds");

// Check error properties
assert_eq!(color_err.category(), ErrorCategory::Format);
assert!(color_err.suggestion().is_some());
```

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

### DialogueInfo Time and Duration Methods

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/events/dialogue_info

This section covers the methods for retrieving timing information from a DialogueInfo struct. It includes functions to get the event's duration in milliseconds and centiseconds, as well as its start time in centiseconds.

```rust
/// Get event duration in milliseconds
#[must_use]
pub const fn duration_ms(&self) -> u32 {
    (self.end_cs - self.start_cs) * 10
}

/// Get event duration in centiseconds
#[must_use]
pub const fn duration_cs(&self) -> u32 {
    self.end_cs - self.start_cs
}

/// Get start time in centiseconds
#[must_use]
pub const fn start_time_cs(&self) -> u32 {
    self.start_cs
}

/// Get end time in centiseconds
#[must_use]
pub const fn end_time_cs(&self) -> u32 {
    self.end_cs
}
```

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

### StyleAnalyzer Initialization

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/styles/analyzer

Provides methods for creating a StyleAnalyzer instance. It can be initialized with default configurations or custom settings.

```rust
impl<'a> StyleAnalyzer<'a> {
    /// Create analyzer with default configuration
    #[must_use]
    pub fn new(script: &'a Script<'a>) -> Self {
        Self::new_with_config(script, StyleAnalysisConfig::default())
    }

    /// Create analyzer with custom configuration
    #[must_use]
    pub fn new_with_config(script: &'a Script<'a>, config: StyleAnalysisConfig) -> Self {
        let mut analyzer = Self { ... };
        // ... initialization logic ...
        analyzer
    }
}
```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/linting/rules/invalid_tag

Provides links to essential Rust documentation and resources, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, the Cargo Guide, and Clippy documentation.

```Rust
Rust Resources:
  - Rust Website: https://www.rust-lang.org/
  - The Book: https://doc.rust-lang.org/book/
  - Standard Library API Reference: https://doc.rust-lang.org/std/
  - Rust by Example: https://doc.rust-lang.org/rust-by-example/
  - Cargo Guide: https://doc.rust-lang.org/cargo/guide/
  - Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### ass-core Crate Overview

Source: https://docs.rs/ass-core/latest/ass_core/plugin/tags/karaoke/index

Provides an overview of the ass-core crate, including its version, license, source code repository, and dependencies. It also highlights the documentation coverage percentage.

```rust
Crate: ass-core
Version: 0.1.1
License: MIT
Repository: https://github.com/wiedymi/ass-rs
Dependencies:
  - ahash ^0.8.11
  - bitflags ^2.4.1
  - bumpalo ^3.14 (optional)
  - criterion ^0.5 (optional)
  - hashbrown ^0.14 (optional)
  - serde ^1.0 (optional)
  - thiserror ^1.0.63
  - wide ^0.7 (optional)
Documentation Coverage: 95.59%
```

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

### Initialize Parser with Registry

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/main

Creates a new `Parser` instance with the provided source text and an optional extension registry. This is useful when working with plugins.

```rust
#[cfg(feature = "plugins")]
pub const fn new_with_registry(
    source: &'a str,
    registry: Option<&'a ExtensionRegistry>,
) -> Self {
    Self {
        source,
        position: 0,
        line: 1,
        version: ScriptVersion::AssV4, // Default, updated when ScriptType found
        sections: Vec::new(),
        issues: Vec::new(),
        styles_format: None,
        events_format: None,
        registry,
    }
}
```

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

### Initialize Parser

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/main

Creates a new `Parser` instance with the provided source text. The parser is used to process ASS subtitle files.

```rust
pub const fn new(source: &'a str) -> Self {
    Self {
        source,
        position: 0,
        line: 1,
        version: ScriptVersion::AssV4, // Default, updated when ScriptType found
        sections: Vec::new(),
        issues: Vec::new(),
        styles_format: None,
        events_format: None,
        #[cfg(feature = "plugins")]
        registry: None,
    }
}
```

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

### Get Span Byte Offset

Source: https://docs.rs/ass-core/latest/src/ass_core/utils/mod

Provides the `span_offset` method, which calculates the byte offset of a given span relative to the start of the source text. It returns `None` if the span is not a valid substring of the source, utilizing the `validate_span` method internally.

```rust
/// Get byte offset of span within source
#[must_use]
pub fn span_offset(&self, span: &str) -> Option<usize> {
    let source_start = self.source.as_ptr() as usize;
    let span_start = span.as_ptr() as usize;

    if self.validate_span(span) {
        Some(span_start - source_start)
    } else {
        None
    }
}
```

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

### ass-core Crate Overview

Source: https://docs.rs/ass-core/latest/ass_core/plugin/sections/aegisub/index

Provides an overview of the ass-core crate, including its version, license, source code links, and dependencies. It also highlights the documentation coverage percentage.

```rust
Crate: ass-core
Version: 0.1.1
License: MIT
Dependencies:
  - ahash ^0.8.11
  - bitflags ^2.4.1
  - bumpalo ^3.14 (optional)
  - criterion ^0.5 (optional)
  - hashbrown ^0.14 (optional)
  - serde ^1.0 (optional)
  - thiserror ^1.0.63
  - wide ^0.7 (optional)
Documentation Coverage: 95.59%
```

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

### Get Performance Impact Function

Source: https://docs.rs/ass-core/latest/ass_core/analysis/events/scoring/fn

The `get_performance_impact` function is part of the `ass_core::analysis::events::scoring` module. It is used to determine the performance impact of subtitle events. The function takes arguments and returns a value, with an example provided for usage.

```Rust
pub fn get_performance_impact(
    // ... arguments ...
) -> PerformanceImpact {
    // ... implementation ...
}
```

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

### Script Analysis Example

Source: https://docs.rs/ass-core/latest/ass_core/analysis/index

Demonstrates how to parse an ASS script, perform analysis, check for linting issues, and resolve styles using the ass_core::analysis module.

```rust
use ass_core::{Script, analysis::ScriptAnalysis};

let script_text = r#"[Script Info]
Title: Test

[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1

[Events\]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
Dialogue: 0,0:00:00.00,0:00:05.00,Default,,0,0,0,,Hello World!
"#;

let script = Script::parse(script_text)?;
let analysis = ScriptAnalysis::analyze(&script)?;

// Check for issues
for issue in analysis.lint_issues() {
    println!("Warning: {}", issue.message());
}

// Get resolved styles
if let Some(style) = analysis.resolve_style("Default") {
    println!("Font: {}", style.font_name());
}
```

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

### Rust: Multiple Events Span Calculation

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/ast/section

Illustrates the calculation of span information when dealing with multiple events, specifically two Dialogue events. This example shows how the span is determined by the earliest start and latest end times across all events within a section.

```rust
let event1 = Event {
            event_type: EventType::Dialogue,
            layer: "0",
            start: "0:00:00.00",
            end: "0:00:05.00",
            style: "Default",
            name: "",
            margin_l: "0",
            margin_r: "0",
            margin_v: "0",
            margin_t: None,
            margin_b: None,
            effect: "",
            text: "First",
            span: Span::new(100, 150, 10, 1),
        };

        let event2 = Event {
            event_type: EventType::Dialogue,
            layer: "0",
            start: "0:00:02.00",
            end: "0:00:07.00",
            style: "Default",
            name: "",
            margin_l: "0",
            margin_r: "0",
            margin_v: "0",
            margin_t: None,
            margin_b: None,
            effect: "",
            text: "Second",
            span: Span::new(160, 210, 10, 1),
        };

        let section_events = Section::Events(vec![event1, event2]);
        let span = section_events.span();
        assert!(span.is_some());
        let span = span.unwrap();
        assert_eq!(span.start, 100);
        assert_eq!(span.end, 210);
```

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

### ass_core::utils Module Overview

Source: https://docs.rs/ass-core/latest/ass_core/utils/utf8/index

Lists the sub-modules and structs available within the ass_core::utils module, providing links to their respective documentation.

```Rust
Module: ass_core::utils

Sub-modules:
  - benchmark_generators
  - errors
  - hashers
  - utf8

Structs:
  - Spans (https://docs.rs/ass-core/latest/ass_core/utils/struct.Spans.html)
```

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

### ass-core Crate Overview

Source: https://docs.rs/ass-core/latest/ass_core/tokenizer/index

Provides an overview of the ass-core Rust crate, including its version, license, dependencies, and documentation status. It also lists supported platforms and available feature flags.

```rust
Crate: ass-core
Version: 0.1.1
License: MIT
Documentation: 95.59% documented
Dependencies:
  - ahash ^0.8.11
  - bitflags ^2.4.1
  - bumpalo ^3.14 (optional)
  - criterion ^0.5 (optional)
  - hashbrown ^0.14 (optional)
  - serde ^1.0 (optional)
  - thiserror ^1.0.63
  - wide ^0.7 (optional)
Platforms:
  - i686-pc-windows-msvc
  - i686-unknown-linux-gnu
  - x86_64-apple-darwin
  - x86_64-pc-windows-msvc
  - x86_64-unknown-linux-gnu
Features:
  - Browse available feature flags
```

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

### Event Struct Definition and Usage

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/ast/event

Defines the `Event` struct for representing subtitle events, including its fields like `event_type`, `layer`, `start`, `end`, and `text`. It also includes methods for checking event types and provides an example of creating an `Event` instance.

```rust
/// Event from `[Events]` section (dialogue, comments, etc.)
///
/// Represents a single event in the subtitle timeline. Events can be dialogue
/// lines, comments, or other commands with associated timing and styling.
/// All fields use zero-copy string references for maximum efficiency.
///
/// # Examples
///
/// ```rust
/// use ass_core::parser::ast::{Event, EventType};
///
/// let event = Event {
///     event_type: EventType::Dialogue,
///     start: "0:00:05.00",
///     end: "0:00:10.00",
///     text: "Hello, world!",
///     ..Event::default()
/// };
///
/// assert!(event.is_dialogue());
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Event<'a> {
    /// Event type (Dialogue, Comment, etc.)
    pub event_type: EventType,

    /// Layer for drawing order (higher layers drawn on top)
    pub layer: &'a str,

    /// Start time in ASS time format (H:MM:SS.CS)
    pub start: &'a str,

    /// End time in ASS time format (H:MM:SS.CS)
    pub end: &'a str,

    /// Text content of the event, including rich text tags
    pub text: &'a str,

    /// Optional style name
    pub style: &'a str,

    /// Name of the actor speaking
    pub actor: &'a str,

    /// Margin information (left, right, vertical)
    pub margin: &'a str,

    /// Effect applied to the event
    pub effect: &'a str,

    /// Effect parameters
    pub effect_params: &'a str,

    /// Span information for the original source text
    #[cfg(debug_assertions)]
    pub span: Range<usize>,
}

/// Enum representing the type of an ASS event.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EventType {
    /// A dialogue line spoken by a character.
    Dialogue,
    /// A comment or metadata line.
    Comment,
    /// Other types of commands or events.
    Other,
}

impl<'a> Event<'a> {
    /// Checks if the event is a dialogue event.
    pub fn is_dialogue(&self) -> bool {
        self.event_type == EventType::Dialogue
    }

    /// Checks if the event is a comment event.
    pub fn is_comment(&self) -> bool {
        self.event_type == EventType::Comment
    }
}

impl<'a> Default for Event<'a> {
    fn default() -> Self {
        Event {
            event_type: EventType::Other,
            layer: "",
            start: "",
            end: "",
            text: "",
            style: "",
            actor: "",
            margin: "",
            effect: "",
            effect_params: "",
            #[cfg(debug_assertions)]
            span: 0..0,
        }
    }
}
```

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

### Get Section Byte Range

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/script

Retrieves the byte range (start..end) for a specified section type. If the section exists and has a valid span, its byte range is returned. Otherwise, it returns `None`. This is useful for accessing raw byte data of a specific section.

```rust
pub fn section_range(&self, section_type: SectionType) -> Option<core::ops::Range<usize>> {
    self.find_section(section_type)?
        .span()
        .map(|s| s.start..s.end)
}
```

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

### ASS Script Performance Summary

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/mod

Illustrates how to check performance metrics and generate recommendations from a `PerformanceSummary` object. This includes checking for performance issues and retrieving a descriptive recommendation string.

```rust
let summary = PerformanceSummary {
    total_events: 100,
    overlapping_events: 15,
    complex_animations: 5,
    large_fonts: 2,
    performance_score: 75,
};

assert!(summary.has_performance_issues());
assert!(summary.recommendation().is_some());
assert!(summary
    .recommendation()
    .unwrap()
    .contains("overlapping events"));
```

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

### Initialize StyleAnalyzer with Config

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/styles/analyzer

Demonstrates initializing the StyleAnalyzer with a custom configuration, including performance thresholds. It then asserts that the analyzer correctly resolves a single default style.

```rust
let config = ass_core::analysis::styles::StyleConfig {
    performance_thresholds: ass_core::analysis::styles::PerformanceThresholds {
        large_font_threshold: 30.0,
        large_outline_threshold: 2.0,
        large_shadow_threshold: 2.0,
        scaling_threshold: 150.0,
    },
};
let analyzer = ass_core::analysis::styles::StyleAnalyzer::new_with_config(&script, config);

assert_eq!(analyzer.resolved_styles().len(), 1);
assert!(analyzer.resolve_style("Default").is_some());
```

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

### ass-core Crate Overview

Source: https://docs.rs/ass-core/latest/ass_core/plugin/sections/index

This snippet provides an overview of the ass-core crate, including its version, license, source code repository, and dependencies. It also highlights the documentation coverage and supported platforms.

```rust
Project: /websites/rs_ass-core
Content:
[ Docs.rs ](https://docs.rs/)
  * [ ass-core-0.1.1 ](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html "High-performance ASS subtitle format parser and analyzer")
    * ass-core 0.1.1 
    * [](https://docs.rs/ass-core/0.1.1/ass_core/plugin/sections/index.html "Get a link to this specific version")
    * [ ](https://docs.rs/crate/ass-core/latest "See ass-core in docs.rs")
    * [MIT](https://spdx.org/licenses/MIT)
    * Links
    * [ ](https://github.com/wiedymi/ass-rs)
    * [ ](https://github.com/wiedymi/ass-rs)
    * [ ](https://crates.io/crates/ass-core "See ass-core in crates.io")
    * [ ](https://docs.rs/crate/ass-core/latest/source/ "Browse source of ass-core-0.1.1")
    * Owners
    * [ ](https://crates.io/users/wiedymi)
    * Dependencies
    *       * [ ahash ^0.8.11 _normal_ ](https://docs.rs/ahash/^0.8.11)
      * [ bitflags ^2.4.1 _normal_ ](https://docs.rs/bitflags/^2.4.1)
      * [ bumpalo ^3.14 _normal_ _optional_ ](https://docs.rs/bumpalo/^3.14)
      * [ criterion ^0.5 _normal_ _optional_ ](https://docs.rs/criterion/^0.5)
      * [ hashbrown ^0.14 _normal_ _optional_ ](https://docs.rs/hashbrown/^0.14)
      * [ serde ^1.0 _normal_ _optional_ ](https://docs.rs/serde/^1.0)
      * [ thiserror ^1.0.63 _normal_ ](https://docs.rs/thiserror/^1.0.63)
      * [ wide ^0.7 _normal_ _optional_ ](https://docs.rs/wide/^0.7)
    * Versions
    * [ **95.59%** of the crate is documented ](https://docs.rs/crate/ass-core/latest)
  * [ Platform ](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html)
    * [i686-pc-windows-msvc](https://docs.rs/crate/ass-core/latest/target-redirect/i686-pc-windows-msvc/ass_core/plugin/sections/index.html)
    * [i686-unknown-linux-gnu](https://docs.rs/crate/ass-core/latest/target-redirect/i686-unknown-linux-gnu/ass_core/plugin/sections/index.html)
    * [x86_64-apple-darwin](https://docs.rs/crate/ass-core/latest/target-redirect/x86_64-apple-darwin/ass_core/plugin/sections/index.html)
    * [x86_64-pc-windows-msvc](https://docs.rs/crate/ass-core/latest/target-redirect/x86_64-pc-windows-msvc/ass_core/plugin/sections/index.html)
    * [x86_64-unknown-linux-gnu](https://docs.rs/crate/ass-core/latest/target-redirect/x86_64-unknown-linux-gnu/ass_core/plugin/sections/index.html)
  * [ Feature flags ](https://docs.rs/crate/ass-core/latest/features "Browse available feature flags of ass-core-0.1.1")


  * [docs.rs](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html)
    * [](https://docs.rs/about)
    * [](https://docs.rs/about/badges)
    * [](https://docs.rs/about/builds)
    * [](https://docs.rs/about/metadata)
    * [](https://docs.rs/about/redirections)
    * [](https://docs.rs/about/download)
    * [](https://docs.rs/about/rustdoc-json)
    * [](https://docs.rs/releases/queue)
    * [](https://foundation.rust-lang.org/policies/privacy-policy/#docs.rs)


  * [Rust](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html)
    * [Rust website](https://www.rust-lang.org/)
    * [The Book](https://doc.rust-lang.org/book/)
    * [Standard Library API Reference](https://doc.rust-lang.org/std/)
    * [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
    * [The Cargo Guide](https://doc.rust-lang.org/cargo/guide/)
    * [Clippy Documentation](https://doc.rust-lang.org/nightly/clippy)


## [Module sections](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html)
##  [ass_core](https://docs.rs/ass-core/latest/ass_core/index.html)0.1.1
## [Module sections](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html)
### [Sections](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html)
  * [Modules](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html#modules "Modules")
  * [Usage](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html#usage "Usage")


### [Module Items](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html#reexports)
  * [Re-exports](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html#reexports "Re-exports")
  * [Modules](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html#modules-1 "Modules")


## [In ass_core::plugin](https://docs.rs/ass-core/latest/ass_core/plugin/index.html)
### [Modules](https://docs.rs/ass-core/latest/ass_core/plugin/index.html#modules)
  * [sections](https://docs.rs/ass-core/latest/ass_core/plugin/sections/index.html)
  * [tags](https://docs.rs/ass-core/latest/ass_core/plugin/tags/index.html)


### [Structs](https://docs.rs/ass-core/latest/ass_core/plugin/index.html#structs)
  * [ExtensionRegistry](https://docs.rs/ass-core/latest/ass_core/plugin/struct.ExtensionRegistry.html)
```

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

### Example Usage of TimingOverlapRule

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/linting/rules/timing_overlap

This Rust code snippet demonstrates how to use the `TimingOverlapRule`. It first analyzes a script using `ScriptAnalysis::analyze`, then creates an instance of `TimingOverlapRule`, and finally calls the `check_script` method to get a list of linting issues. An assertion is included to verify that overlapping issues are detected.

```rust
let analysis = ScriptAnalysis::analyze(&script)?;
let rule = TimingOverlapRule;
let issues = rule.check_script(&analysis);
assert!(!issues.is_empty()); // Should detect the overlap
# Ok::<(), Box<dyn std::error::Error>>(())
```

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

### Test Invalid Start Time Format Error

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/events/overlap

Tests the scenario where an invalid start time format is provided to the `find_overlapping_events` function. It asserts that an error is returned and the error message indicates an invalid start time.

```rust
let events = vec![
            create_test_event("invalid_time", "0:00:05.00"),
            create_test_event("0:00:03.00", "0:00:08.00"),
        ];
        let result = find_overlapping_events(&events);
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("Invalid start time format"));
```

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

### ass-core Crate Information

Source: https://docs.rs/ass-core/latest/ass_core/tokenizer/state/index

Provides an overview of the ass-core crate, including its version, license, dependencies, and documentation status. It also lists supported platforms for the crate.

```rust
Crate: ass-core
Version: 0.1.1
License: MIT
Documentation: 95.59% documented
Dependencies:
  - ahash ^0.8.11
  - bitflags ^2.4.1
  - bumpalo ^3.14 (optional)
  - criterion ^0.5 (optional)
  - hashbrown ^0.14 (optional)
  - serde ^1.0 (optional)
  - thiserror ^1.0.63
  - wide ^0.7 (optional)
Platforms:
  - i686-pc-windows-msvc
  - i686-unknown-linux-gnu
  - x86_64-apple-darwin
  - x86_64-pc-windows-msvc
  - x86_64-unknown-linux-gnu
```

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

### Sort Events by Start Time

Source: https://docs.rs/ass-core/latest/src/ass_core/analysis/events/utils

Tests the `sort_events_by_time` function to ensure it correctly sorts a mutable slice of events based on their start times in centiseconds (cs). Verifies that the first event in the sorted slice has the earliest start time.

```rust
    #[test]
    fn sort_events_maintains_order() {
        let mut events = vec![
            create_test_dialogue_info("0:00:05.00", "0:00:10.00"),
            create_test_dialogue_info("0:00:00.00", "0:00:05.00"),
            create_test_dialogue_info("0:00:02.00", "0:00:07.00"),
        ];

        sort_events_by_time(&mut events);

        assert_eq!(events[0].start_time_cs(), 0); // 0:00:00.00
    }
```

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

### Calculate Event Duration in Centiseconds

Source: https://docs.rs/ass-core/latest/src/ass_core/parser/ast/event

Calculates the duration of an event in centiseconds by subtracting the start time from the end time. Returns 0 if the start time is greater than the end time. Returns an error if either start or end time format is invalid.

```rust
pub fn duration_cs(&self) -> Result<u32, crate::utils::CoreError> {
    let start = self.start_time_cs()?;
    let end = self.end_time_cs()?;
    Ok(end.saturating_sub(start))
}
```

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

### Find Section Header Start (Rust)

Source: https://docs.rs/ass-core/latest/ass_core/parser/incremental/fn

Locates the beginning of a section header in a string source before a specified position. It takes the source string, a starting hint index, and the type of section to find. Returns the starting index of the header or a ParseError if not found.

```APIDOC
find_section_header_start:
  Find the start of a section header before the given position
  Parameters:
    source: &str - The input string to search within.
    start_hint: usize - An index providing a hint for where to start searching.
    section_type: SectionType - The type of section header to find.
  Returns:
    Result<usize, ParseError> - Ok(usize) with the start index if found, Err(ParseError::SectionNotFound) otherwise.
```

```rust
pub fn find_section_header_start(
    source: &str,
    start_hint: usize,
    section_type: SectionType,
) -> Result<usize, ParseError>
```
Tokens:
Raw