ASS Editor

https://docs.rs/ass-editor/latest/
Admin
ASS Editor is a high-performance, ergonomic editor layer for ASS subtitles, offering an interactive...
Tokens:525,966
Snippets:3,354
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Rust Ecosystem Links

Source: https://docs.rs/ass-editor/latest/ass_editor/commands/delta_commands/index

Provides links to essential Rust resources, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, The Cargo Guide, and Clippy Documentation. These resources are valuable 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 Documentation Resources

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/builtin/auto_complete

Provides links to essential Rust programming resources, including the official website, The Book, standard library API reference, Rust by Example, 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
```

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

### Rust Documentation Resources

Source: https://docs.rs/ass-editor/latest/src/ass_editor/formats/webvtt/mod

Provides links to essential Rust programming resources, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, and the 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 Documentation Resources

Source: https://docs.rs/ass-editor/latest/ass_editor/extensions/builtin/auto_complete/index

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.

```Rust
Rust Documentation:
- 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 Documentation Resources

Source: https://docs.rs/ass-editor/latest/src/ass_editor/formats/ass/mod

Provides links to essential Rust programming 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/
- The Cargo Guide: https://doc.rust-lang.org/cargo/guide/
- Clippy Documentation: https://doc.rust-lang.org/nightly/clippy
```

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

### Rust Documentation Resources

Source: https://docs.rs/ass-editor/latest/ass_editor/commands/index

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

```Rust
Rust Documentation:
- 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 Documentation Resources

Source: https://docs.rs/ass-editor/latest/src/ass_editor/utils/mod

Provides links to essential Rust programming resources. These include 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
```

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

### Rust Documentation Resources

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/mod

Provides links to essential Rust programming resources, including the official Rust website, The Book, standard library API reference, Rust by Example, 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
```

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

### Rust Standard Library and Tools

Source: https://docs.rs/ass-editor/latest/ass_editor/extensions/builtin/index

Provides links to essential Rust documentation and resources, including the Rust website, The Book, Standard Library API Reference, Rust by Example, 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
```

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

### Rust Standard Library and Tools

Source: https://docs.rs/ass-editor/latest/ass_editor

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

```APIDOC
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-editor/latest/ass_editor/utils/formats/index

This section provides links to various resources within the Rust ecosystem, including the official Rust website, documentation for 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
```

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

### Extension Manager Initialization

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/mod

Tests the initialization of an ExtensionManager and verifies that it starts with an empty list of extensions.

```rust
let manager = ExtensionManager::new();
assert_eq!(manager.list_extensions().len(), 0);
```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/history

Provides links to essential resources within the Rust ecosystem. These include the main Rust website, The Book for learning Rust, the 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
```

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

### Related Rust Documentation Resources

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/document

This section provides links to essential Rust programming resources, including the official Rust website, The Book, the Standard Library API Reference, Rust by Example, the Cargo Guide, and Clippy documentation. These resources are valuable 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 Standard Library and Tools

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

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

```APIDOC
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
```

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

### Record Operation Example

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/history

Demonstrates recording a simple operation using the UndoManager. This snippet shows the creation of an operation, a result, and how to record them.

```rust
let operation = Operation::Insert {
            position: Position::new(5),
            text: "test2".to_string(),
        };
        manager.record_operation(operation, "Should not record".to_string(), &result);
        assert_eq!(manager.stats().undo_count, 0);
```

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

### Example: Setting Script Info Fields

Source: https://docs.rs/ass-editor/latest/src/ass_editor/commands/macros

This example demonstrates how to use the `script_info!` macro to set the 'Title' and 'Author' fields of an ASS document. It initializes a document, applies the macro, and asserts that the changes are reflected in the document's text.

```rust
use ass_editor::{EditorDocument, script_info, Position};

let mut doc = EditorDocument::from_content("[Script Info]\nTitle: \nAuthor: ").unwrap();

// Set script info fields - they must already exist in the document
doc.set_script_info_field("Title", "My Movie").unwrap();
doc.set_script_info_field("Author", "John Doe").unwrap();

assert!(doc.text().contains("Title: My Movie"));
assert!(doc.text().contains("Author: John Doe"));
```

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

### ASS Editor Quick Start

Source: https://docs.rs/ass-editor/latest/ass_editor/index

Demonstrates the basic usage of the ASS Editor library, including creating a document from content, performing text edits using positions and ranges, and utilizing undo/redo functionality.

```rust
use ass_editor::{EditorDocument, Position, Range};

// Create a new document with ASS content
let mut doc = EditorDocument::from_content(r#"\n[Script Info]\nTitle: My Subtitle\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"#).unwrap();

// Basic text editing with position-based operations
let pos = Position::new(doc.text().len() - 11); // Before "Hello World"
doc.insert(pos, "Welcome! ").unwrap();

// Range-based operations
let range = Range::new(Position::new(pos.offset), Position::new(pos.offset + 8));
doc.replace(range, "Hi").unwrap();

// Undo/redo support
assert!(doc.can_undo());
doc.undo().unwrap();
assert!(doc.can_redo());
doc.redo().unwrap();

println!("Final text contains: {}", doc.text().contains("Hi World"));
```

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

### Get Event Start Time

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/fluent

Retrieves the start time of an ASS event as a string. This method is useful for accessing the specific start time of an event. It depends on the `get()` method to fetch event details.

```rust
/// Get event start time
pub fn start_time(self) -> Result<Option<String>> {
    Ok(self.get()?.map(|info| info.event.start))
}
```

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

### Create SyntaxHighlightExtension

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/builtin/syntax_highlight

Constructor for the SyntaxHighlightExtension. It initializes the extension with basic information such as name, version, author, description, capabilities, and license.

```rust
impl SyntaxHighlightExtension {
    /// Create a new syntax highlighting extension
    pub fn new() -> Self {
        let info = ExtensionInfo::new(
            "syntax-highlight".to_string(),
            "1.0.0".to_string(),
            "ASS-RS Team".to_string(),
            "Built-in syntax highlighting for ASS/SSA files".to_string(),
        )
        .with_capability(ExtensionCapability::SyntaxHighlighting)
        .with_license("MIT".to_string());

        Self {
            info,
        }
    }
}
```

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

### Get Event Timing

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/fluent

Retrieves the start and end times of an ASS event. The times are returned as a tuple of strings in centiseconds. This method relies on the underlying `get()` method to fetch event information.

```rust
/// Get event timing as (start, end) in centiseconds
pub fn timing(self) -> Result<Option<(String, String)>> {
    Ok(self.get()?.map(|info| (info.event.start, info.event.end)))
}
```

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

### Event Usage Example

Source: https://docs.rs/ass-editor/latest/ass_editor/struct

Demonstrates how to create and use an Event object. This example shows initializing an Event with specific properties like event type, start and end times, and text content, and then asserting a method call.

```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());
```

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

### Quick Start: Basic ASS Document Editing

Source: https://docs.rs/ass-editor/latest/ass_editor

Demonstrates creating an ASS document from content, performing basic text insertions and replacements using position and range operations, and utilizing undo/redo functionality.

```rust
use ass_editor::{EditorDocument, Position, Range};

// Create a new document with ASS content
let mut doc = EditorDocument::from_content(r#"\n[Script Info]\nTitle: My Subtitle\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\"#).unwrap();

// Basic text editing with position-based operations
let pos = Position::new(doc.text().len() - 11); // Before "Hello World"
doc.insert(pos, "Welcome! ").unwrap();

// Range-based operations
let range = Range::new(Position::new(pos.offset), Position::new(pos.offset + 8));
doc.replace(range, "Hi").unwrap();

// Undo/redo support
assert!(doc.can_undo());
doc.undo().unwrap();
assert!(doc.can_redo());
doc.redo().unwrap();

println!("Final text contains: {}", doc.text().contains("Hi World"));
```

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

### Range Struct and Usage

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/position

Defines the `Range` struct to represent a half-open interval [start, end) within a document. The start is inclusive, and the end is exclusive, following common text editor conventions. Includes an example of creating a range.

```rust
/// A range in a document represented by start and end positions.
/// Ranges are half-open intervals [start, end) where start is inclusive
/// and end is exclusive. This matches standard text editor conventions.
///
/// # Examples
///
/// ```
/// use ass_editor::{Position, Range, EditorDocument};
///
/// let doc = EditorDocument::from_content("Hello World").unwrap();
/// let range = Range::new(Position::new(0), Position::new(5)); // "Hello"
/// ```
// Note: The actual definition of Range and its `new` method are not provided in the input text, 
// but the description and example imply its existence and usage.
```

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

### Quick Start: Basic ASS Document Editing

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

Demonstrates creating an ASS document from content, performing basic text insertions and replacements using position and range operations, and utilizing undo/redo functionality.

```rust
use ass_editor::{EditorDocument, Position, Range};

// Create a new document with ASS content
let mut doc = EditorDocument::from_content(r#"\n[Script Info]\nTitle: My Subtitle\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\"#).unwrap();

// Basic text editing with position-based operations
let pos = Position::new(doc.text().len() - 11); // Before "Hello World"
doc.insert(pos, "Welcome! ").unwrap();

// Range-based operations
let range = Range::new(Position::new(pos.offset), Position::new(pos.offset + 8));
doc.replace(range, "Hi").unwrap();

// Undo/redo support
assert!(doc.can_undo());
doc.undo().unwrap();
assert!(doc.can_redo());
doc.redo().unwrap();

println!("Final text contains: {}", doc.text().contains("Hi World"));
```

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

### Test Module Setup

Source: https://docs.rs/ass-editor/latest/src/ass_editor/formats/mod

Sets up the test module, importing necessary items from the parent module and conditionally importing `ToString` and `format` from `alloc` when the `std` feature is not enabled.

```rust
mod tests {
    use super::*;
    #[cfg(not(feature = "std"))]
    use alloc::string::ToString;
    #[cfg(not(feature = "std"))]
    use alloc::{format, string::String, vec};

    #[test]
    fn placeholder_test() {}
}
```

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

### Get Duration in Centiseconds (Rust)

Source: https://docs.rs/ass-editor/latest/ass_editor/struct

Calculates the duration of an ASS event in centiseconds by subtracting the start time from the end time. If the start time is greater than the end time, it returns 0. Returns a Result with the duration or a CoreError if time parsing fails.

```rust
pub fn duration_cs(&self) -> Result<u32, CoreError>
```

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

### Create and Configure ExtensionInfo

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/mod

Demonstrates the creation of an ExtensionInfo object with various properties like name, version, author, description, capabilities, dependencies, homepage, and license. It also includes assertions to verify the set properties.

```rust
let info = ExtensionInfo::new(
            "test-extension".to_string(),
            "1.0.0".to_string(),
            "Test Author".to_string(),
            "A test extension".to_string(),
        )
        .with_capability(ExtensionCapability::TextProcessing)
        .with_dependency("core-extension".to_string())
        .with_homepage("https://example.com".to_string())
        .with_license("MIT".to_string());

        assert_eq!(info.name, "test-extension");
        assert_eq!(info.version, "1.0.0");
        assert!(info.has_capability(&ExtensionCapability::TextProcessing));
        assert_eq!(info.dependencies.len(), 1);
        assert_eq!(info.homepage, Some("https://example.com".to_string()));
        assert_eq!(info.license, Some("MIT".to_string()));
```

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

### SrtFormat Constructor

Source: https://docs.rs/ass-editor/latest/ass_editor/formats/srt/struct

Provides a function to create a new instance of the SrtFormat handler. This is the primary way to get started with SRT format operations.

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

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

### Manage Configuration Settings

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/mod

Demonstrates setting and retrieving configuration values using the manager. This involves calling `set_config` with a key-value pair and then verifying the retrieval with `get_config`.

```rust
manager.set_config("test".to_string(), "value".to_string());
assert_eq!(manager.get_config("test"), Some("value".to_string()));
```

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

### Get First Sorted Dialogue

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/fluent

Demonstrates how to retrieve the first dialogue event after sorting all dialogues by their start times. This is useful for accessing the earliest dialogue in the document.

```rust
let first_dialogue = doc.events().dialogues().sort_by_time().first().unwrap();

assert!(first_dialogue.is_some());
let first = first_dialogue.unwrap();
assert_eq!(first.event.text, "Another dialogue");
```

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

### Create New WebVttFormat Instance

Source: https://docs.rs/ass-editor/latest/ass_editor/formats/webvtt/struct

A constructor function to create a new instance of the WebVttFormat handler. This is the primary way to get started with the WebVTT format processing.

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

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

### ASS Editor Built-in Syntax Highlighting

Source: https://docs.rs/ass-editor/latest/ass_editor/all

Documentation for the syntax highlighting extension, covering tokenization and configuration.

```rust
/// Represents a token identified during syntax highlighting.
struct HighlightToken;

/// Configuration for syntax highlighting.
struct SyntaxHighlightConfig;

/// An extension that performs syntax highlighting.
struct SyntaxHighlightExtension;
```

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

### Get Sorted Dialogue Indices

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/fluent

Shows how to retrieve the indices of dialogue events after sorting them by their start times. This is useful when you need to reference the original positions of events after applying sorting.

```rust
let dialogue_indices = doc.events().dialogues().sort_by_time().indices().unwrap();

assert_eq!(dialogue_indices.len(), 3);
// Should be indices in time order: 1, 0, 3 (based on start times)
assert_eq!(dialogue_indices, vec![1, 0, 3]);
```

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

### ass-editor Crate Overview

Source: https://docs.rs/ass-editor/latest/ass_editor/commands/macros/index

Provides a high-level overview of the ass-editor crate, including its version, license, source code repository, and dependencies. It also lists supported build targets and feature flags.

```rust
Crate: ass-editor
Version: 0.1.1
License: MIT
Repository: https://github.com/wiedymi/ass-rs
Dependencies:
  - ass-core ^0.1.1
  - bumpalo ^3.14 (optional)
  - fst ^0.4.7 (optional)
  - futures ^0.3 (optional)
  - hashbrown ^0.14 (optional)
  - parking_lot ^0.12 (optional)
  - regex ^1.10 (optional)
  - ropey ^1.6.1 (optional)
  - serde ^1.0 (optional)
  - static_assertions ^1.1 (optional)
  - thiserror ^1.0.63 (optional)
  - tokio ^1.35 (optional)
  - getrandom ^0.2
Dev Dependencies:
  - criterion ^0.5
  - pretty_assertions ^1.4
  - proptest ^1.4
  - tempfile ^3.8
Documentation Coverage: 90.95%
Supported Platforms:
  - i686-pc-windows-msvc
  - i686-unknown-linux-gnu
  - x86_64-apple-darwin
  - x86_64-pc-windows-msvc
  - x86_64-unknown-linux-gnu
```

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

### Supported Platforms for ass-editor

Source: https://docs.rs/ass-editor/latest/ass_editor/commands/style_commands/index

Lists the platforms for which the ass-editor crate has been compiled and documented.

```rust
Platforms:
  - i686-pc-windows-msvc
  - i686-unknown-linux-gnu
  - x86_64-apple-darwin
  - x86_64-pc-windows-msvc
  - x86_64-unknown-linux-gnu
```

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

### ASS Editor Sessions

Source: https://docs.rs/ass-editor/latest/ass_editor/all

Documentation for managing editor sessions, including session configuration, statistics, and session management.

```rust
/// Represents an active editor session.
struct EditorSession;

/// Manages multiple editor sessions.
struct EditorSessionManager;

/// Configuration for an editor session.
struct SessionConfig;

/// Statistics related to an editor session.
struct SessionStats;
```

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

### Initialize and Parse Document

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/document

Demonstrates initializing a document's registry and parsing ASS content with extensions. It verifies the registry initialization and counts the number of sections after parsing.

```rust
let mut doc = EditorDocument::new();
assert!(doc.registry().is_none());

// Initialize with registry
doc.initialize_registry().unwrap();
assert!(doc.registry().is_some());

// Parse with extensions
doc.insert(Position::new(0), "[Script Info]\nTitle: Test\n\n[Events]\nDialogue: 0,0:00:00.00,0:00:05.00,Default,,0,0,0,{\\b1}Bold{\\b0} text").unwrap();

let section_count = doc
    .parse_with_extensions(|script| script.sections().len())
    .unwrap();
assert_eq!(section_count, 2);
```

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

### Extension Command Creation and Properties

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/mod

Demonstrates the creation of an ExtensionCommand with various properties like ID, name, description, shortcut, category, and document requirement. It then asserts the correct assignment of these properties.

```rust
let command = ExtensionCommand::new(
    "test-command".to_string(),
    "Test Command".to_string(),
    "A test command".to_string(),
)
.with_shortcut("Ctrl+T".to_string())
.with_category("Testing".to_string())
.requires_document(false);

assert_eq!(command.id, "test-command");
assert_eq!(command.shortcut, Some("Ctrl+T".to_string()));
assert_eq!(command.category, "Testing");
assert!(!command.requires_document);
```

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

### Search Index Factory Function

Source: https://docs.rs/ass-editor/latest/src/ass_editor/utils/indexing

Shows how to use a factory function to create a search index. This example demonstrates creating an index and preparing a document for potential indexing.

```rust
let index = create_search_index();
let content = "[Script Info]\nTitle: Test";
let _document = EditorDocument::from_content(content).unwrap();
```

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

### Rustdoc Search Syntax Examples

Source: https://docs.rs/ass-editor/latest/help

Demonstrates various search syntaxes supported by Rustdoc to refine search queries. This includes prefixing searches with item kinds, searching by type signature, exact name matching, and path-based searching.

```rust
fn:my_function
mod:my_module
struct:MyStruct
enum:MyEnum
trait:MyTrait
type:MyType
macro:my_macro
const:MY_CONST
"exact_name"
vec -> usize
-> vec
String, enum:Cow -> bool
-> [u8]
[] -> Option
vec::Vec
```

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

### Syntax Highlight Extension Initialization and Capabilities

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/builtin/syntax_highlight

Verifies the correct initialization of the SyntaxHighlightExtension and checks if it possesses the expected capabilities, such as syntax highlighting.

```rust
let ext = SyntaxHighlightExtension::new();
assert_eq!(ext.info().name, "syntax-highlight");
assert!(ext.info().has_capability(&ExtensionCapability::SyntaxHighlighting));
```

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

### Sort ASS Events by Time

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/fluent

Shows how to sort ASS events based on their start times. The `by_time()` method on the events query sorts the events chronologically. The example asserts the number of events and the text of the first event after sorting.

```rust
let mut doc = EditorDocument::from_content(TEST_CONTENT).unwrap();

// Test sorting by time (should reorder events)
let by_time = doc.events().by_time().execute().unwrap();
assert_eq!(by_time.len(), 3);
assert_eq!(by_time[0].event.text, "First by time");
```

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

### ASS Editor Formats

Source: https://docs.rs/ass-editor/latest/ass_editor/all

Documentation for subtitle format handling, including general format information, options, registry, and specific format implementations.

```rust
/// Information about a subtitle format.
struct FormatInfo;

/// Options for subtitle format processing.
struct FormatOptions;

/// Manages a collection of subtitle formats.
struct FormatRegistry;

/// Represents the result of a format operation.
struct FormatResult;

/// Represents the ASS subtitle format.
struct AssFormat;

/// Represents the SRT subtitle format.
struct SrtFormat;

/// Represents the WebVTT subtitle format.
struct WebVttFormat;
```

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

### Rust Ecosystem Links

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

This snippet provides links to various resources within the Rust ecosystem, including the main Rust website, documentation for 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
```

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

### ass-editor Development Dependencies

Source: https://docs.rs/ass-editor/latest/src/ass_editor/lib

Lists the development dependencies used for testing and benchmarking the ass-editor crate.

```rust
criterion ^0.5
pretty_assertions ^1.4
proptest ^1.4
tempfile ^3.8
```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-editor/latest/ass_editor/extensions/registry_integration/index

Provides links to essential Rust resources, including the official Rust website, The Book, standard library documentation, and Cargo guide.

```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
```

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

### ass-editor Crate Overview

Source: https://docs.rs/ass-editor/latest/ass_editor/formats/webvtt/index

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

```rust
Crate: ass-editor
Version: 0.1.1
License: MIT
Repository: https://github.com/wiedymi/ass-rs
Dependencies:
  - ass-core ^0.1.1
  - bumpalo ^3.14
  - fst ^0.4.7
  - futures ^0.3
  - hashbrown ^0.14
  - parking_lot ^0.12
  - regex ^1.10
  - ropey ^1.6.1
  - serde ^1.0
  - static_assertions ^1.1
  - thiserror ^1.0.63
  - tokio ^1.35
  - getrandom ^0.2
Dev Dependencies:
  - criterion ^0.5
  - pretty_assertions ^1.4
  - proptest ^1.4
  - tempfile ^3.8
Documentation Coverage: 90.95%
```

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

### Apply Karaoke with Manual Syllables

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/fluent

Demonstrates how to apply a karaoke effect to a specific range of text within a document. This example shows the use of `karaoke()`, `in_range()`, `generate()`, `manual_syllables()`, and `execute()` methods. It asserts that the text starts with a prefix, contains the karaoke tag, and preserves the original appended text.

```rust
let mut doc = Document::new();
doc.append("Prefix: Chain test");

let karaoke_range = Range::new(Position::new(8), Position::new(doc.text().len()));
doc.karaoke()
    .in_range(karaoke_range)
    .generate(45)
    .manual_syllables()
    .execute()
    .unwrap();

let text = doc.text();
assert!(text.starts_with("Prefix: "));
assert!(text.contains("\\k45"));
assert!(text.contains("Chain test"));
```

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

### ASS Editor Main Library File

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/builtin/syntax_highlight

This entry refers to the main library file of the ass-editor crate, which serves as the entry point for the library.

```rust
lib.rs
```

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

### Build Dialogue Event with V4++ Format

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/builders

This example demonstrates how to use the EventBuilder to create a dialogue event with the V4++ format. It sets various properties like start time, end time, style, margins, and text, then builds the event using a specified field order. The resulting event string is then asserted for correctness.

```rust
let event = EventBuilder::dialogue()
            .start_time("0:00:05.00")
            .end_time("0:00:10.00")
            .style("Main")
            .margin_top(5)
            .margin_bottom(10)
            .text("V4++ format")
            .build_with_format(&[
                "Layer", "Start", "End", "Style", "Name", "MarginL", "MarginR", "MarginT",
                "MarginB", "Effect", "Text",
            ])
            .unwrap();

        assert_eq!(
            event,
            "Dialogue: 0,0:00:05.00,0:00:10.00,Main,,0,0,5,10,,V4++ format"
        );
```

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

### Fluent Operations - Start at Document Start

Source: https://docs.rs/ass-editor/latest/ass_editor/core/document/struct

Begins a fluent editing operation from the very beginning of the ASS document. This is useful for operations that need to be applied from the start.

```rust
pub fn at_start(&mut self) -> AtPosition<'_>
```

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

### Create New ExtensionInfo

Source: https://docs.rs/ass-editor/latest/src/ass_editor/extensions/mod

A constructor function to create a new ExtensionInfo instance with essential metadata: name, version, author, and description. Other fields are initialized to default values.

```rust
impl ExtensionInfo {
    /// Create a new extension info
    pub fn new(name: String, version: String, author: String, description: String) -> Self {
        Self {
            name,
            version,
            author,
            description,
            capabilities: Vec::new(),
            dependencies: Vec::new(),
            homepage: None,
            license: None,
        }
    }
}
```

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

### Shift Start Time of Events

Source: https://docs.rs/ass-editor/latest/src/ass_editor/commands/event_commands

Creates a `TimingAdjustCommand` to adjust only the start times of specified events, keeping their durations constant. The `offset_cs` is applied to both start and end times.

```rust
    /// Adjust only start times (keep duration constant)
    pub fn shift_start(event_indices: Vec<usize>, offset_cs: i32) -> Self {
        Self::new(event_indices, offset_cs, offset_cs)
    }
```

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

### Style Management with StyleBuilder

Source: https://docs.rs/ass-editor/latest/src/ass_editor/lib

Illustrates how to create and manage ASS styles using the `StyleBuilder` pattern. This includes setting font properties, size, color, and bold attributes, and then applying these styles to the document.

```rust
let mut doc = EditorDocument::new();

// Create styles with builder pattern
let style = StyleBuilder::new()
    .font("Arial")
    .size(24)
    .color("&H00FFFFFF")
    .bold(true);

// Apply styles to document
doc.styles().create("Title", style).unwrap();
```

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

### Edit ASS Event Fields by Index in Rust

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/document

Demonstrates editing all fields of an ASS dialogue event using the `edit_event_by_index` method. This function takes the index of the event and a closure to modify its fields. It allows updating 'layer', 'start', 'end', 'style', 'name', 'margin_l', 'margin_r', 'margin_v', 'effect', and 'text'. The example shows how to initialize a document from content, perform the edit, and verify the changes.

```rust
use ass_editor::core::document::EditorDocument;

fn main() {
    let content = r#"[Script Info]
Title: Test

[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
Dialogue: 0,0:00:00.00,0:00:05.00,Default,Speaker,10,20,30,fade,Original text"#;

    let mut doc = EditorDocument::from_content(content).unwrap();

    // Edit all possible fields
    let result = doc.edit_event_by_index(0, |_event| {
        vec![
            ("layer", "1".to_string()),
            ("start", "0:00:01.00".to_string()),
            ("end", "0:00:06.00".to_string()),
            ("style", "Custom".to_string()),
            ("name", "NewSpeaker".to_string()),
            ("margin_l", "15".to_string()),
            ("margin_r", "25".to_string()),
            ("margin_v", "35".to_string()),
            ("effect", "scroll".to_string()),
            ("text", "Completely new text".to_string()),
        ]
    });

    assert!(result.is_ok());
    let new_line = result.unwrap();

    // Verify all fields were updated
    assert!(new_line.contains("Dialogue: 1,"));
    assert!(new_line.contains("0:00:01.00"));
    assert!(new_line.contains("0:00:06.00"));
    assert!(new_line.contains("Custom"));
    assert!(new_line.contains("NewSpeaker"));
    assert!(new_line.contains("15"));
    assert!(new_line.contains("25"));
    assert!(new_line.contains("35"));
    assert!(new_line.contains("scroll"));
    assert!(new_line.contains("Completely new text"));
    assert!(new_line.contains("Updated comment"));
}

```

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

### StyleBuilder Initialization and Configuration

Source: https://docs.rs/ass-editor/latest/ass_editor/core/builders/struct

Provides methods for creating and configuring StyleBuilder instances. Includes methods for creating a new builder, a builder with default values, and setting the style name.

```rust
pub struct StyleBuilder { /* private fields */ }

// Create a new style builder
pub fn new() -> Self;

// Create a style builder with default values
pub fn default_style() -> Self;

// Set style name
pub fn name(self, name: &[str]) -> Self;
```

```APIDOC
Struct StyleBuilder
  Summary: Builder for creating ASS styles with fluent API

  Methods:
    new() -> Self
      Description: Create a new style builder

    default_style() -> Self
      Description: Create a style builder with default values

    name(self, name: &[str]) -> Self
      Description: Set style name
      Parameters:
        name: &[str] - The name of the style
```

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

### Create Position at Document Start (Rust)

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/position

Provides a constant function to create a `Position` struct representing the start of a document. It initializes line, column, and offset to their respective starting values (1, 1, and 0).

```rust
pub const fn at_start() -> Self {
    Self {
        line: Some(1),
        column: Some(1),
        offset: Some(0),
    }
}
```

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

### Shift Event Start Time

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/fluent

Demonstrates shifting the start time of an event in an ASS document. This test verifies that the start time of the first event is correctly adjusted by a specified duration, while subsequent events remain unaffected.

```rust
let mut doc = EditorDocument::from_content(TEST_CONTENT).unwrap();

// Only first event should change
assert!(doc.text().contains("0:00:02.00,0:00:05.00")); // First event start shifted
assert!(doc.text().contains("0:00:05.00,0:00:10.00")); // Second event unchanged
```

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

### Supported Platforms

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

Lists the target platforms for which the ass-editor crate has been compiled and documented.

```rust
Supported Platforms:
  - i686-pc-windows-msvc
  - i686-unknown-linux-gnu
  - x86_64-apple-darwin
  - x86_64-pc-windows-msvc
  - x86_64-unknown-linux-gnu
```

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

### Event Channel Creation and Configuration

Source: https://docs.rs/ass-editor/latest/src/ass_editor/events/mod

Shows how to create a new EventChannel with default settings and verify its initial statistics. It also demonstrates creating an EventChannel with custom configuration, including maximum handlers and logging enablement, and asserts that the configuration is applied correctly.

```rust
let channel = EventChannel::new();
assert_eq!(channel.stats().handlers_count, 0);
assert_eq!(channel.stats().events_dispatched, 0);
```

```rust
let config = EventChannelConfig {
    max_handlers: 50,
    enable_logging: true,
    ..Default::default()
};

let channel = EventChannel::with_config(config);
assert_eq!(channel.config.max_handlers, 50);
assert!(channel.config.enable_logging);
```

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

### Position Operations Example

Source: https://docs.rs/ass-editor/latest/src/ass_editor/commands/macros

This example shows how to insert text into an ASS document at a specific position using the `insert` method. While a `at_pos!` macro is mentioned in the documentation, the example uses direct method calls for clarity and current implementation.

```rust
use ass_editor::{EditorDocument, Position};

let mut doc = EditorDocument::from_content("Hello world!").unwrap();

// Note: at_pos! macro doesn't exist in the current implementation
// Using direct methods instead
doc.insert(Position::new(5), " beautiful").unwrap();
assert_eq!(doc.text(), "Hello beautiful world!");
```

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

### Rust Ecosystem Links

Source: https://docs.rs/ass-editor/latest/src/ass_editor/commands/style_commands

Provides general links to resources within the Rust programming language ecosystem. These links are useful for learning Rust, referencing the standard library, and understanding build tools.

```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
```

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

### Start Event Query

Source: https://docs.rs/ass-editor/latest/src/ass_editor/core/fluent

Initiates a query chain for filtering and sorting ASS events. This method returns an `EventQuery` object, which serves as the starting point for building complex event queries.

```rust
/// Start a query chain for filtering and sorting events
pub fn query(self) -> EventQuery<'a> {
    EventQuery::new(self.document)
}
```
Tokens:
Raw