### Create Subtitle Cues Programmatically in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Creates subtitle cues manually with precise timing control using the `Subtitles.Cue` and `Subtitles.Time` structures. Allows creation using Time components, seconds values, or start time with duration. The output is a Subtitles object containing the created cues.

```swift
import SwiftSubtitles

// Create cues with Time components (hour, minute, second, millisecond)
let cue1 = Subtitles.Cue(
    position: 1,
    startTime: Subtitles.Time(minute: 10),
    endTime: Subtitles.Time(minute: 11),
    text: "First subtitle line"
)

let cue2 = Subtitles.Cue(
    position: 2,
    startTime: Subtitles.Time(minute: 13, second: 5),
    endTime: Subtitles.Time(minute: 15, second: 10, millisecond: 101),
    text: "Second entry"
)

// Create cues with seconds values
let cue3 = Subtitles.Cue(
    position: 3,
    startTimeInSeconds: 920.5,
    endTimeInSeconds: 925.0,
    text: "Third entry using seconds"
)

// Create cues with start time and duration
let cue4 = Subtitles.Cue(
    position: 4,
    startTime: Subtitles.Time(minute: 16),
    duration: 5.5,  // 5.5 seconds duration
    text: "Fourth entry with duration"
)

let subtitles = Subtitles([cue1, cue2, cue3, cue4])
print("Created (subtitles.cues.count) cues")  // Output: Created 4 cues

```

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

### CSV Coder with Custom Fields in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Illustrates how to use the CSV coder for decoding and encoding subtitle data with custom field configurations. It covers both default CSV formats and custom layouts with specified headers, delimiters, and export options. An example of encoding a single cue with custom fields is provided.

```swift
import SwiftSubtitles

// Default CSV format: position, startTime, endTime, text
let defaultCsvCoder = Subtitles.Coder.CSV()

let csvContent = """
No.,Timecode In,Timecode Out,Subtitle
1,00:00:00:599,00:00:04:160,"Hello, my name is Alice Miller"
2,00:00:04:160,00:00:06:770,"and we're the owners of ""Miller Bakery"".."
"""

let subtitles = try defaultCsvCoder.decode(csvContent)
print("CSV cues: \(subtitles.cues.count)")  // Output: CSV cues: 2

// Custom CSV format with speaker and duration
let customCsvCoder = Subtitles.Coder.CSV(
    fields: [
        .position(title: "ID"),
        .speaker(title: "Speaker"),
        .startTimeInSeconds(title: "Start (s)"),
        .durationInSeconds(title: "Duration (s)"),
        .text(title: "Text")
    ],
    delimiter: .comma,
    exportColumnHeaders: true
)

let cue = Subtitles.Cue(
    position: 1,
    startTime: Subtitles.Time(second: 30),
    duration: 5.0,
    text: "Custom format example",
    speaker: "Narrator"
)

let encoded = try customCsvCoder.encode(subtitles: Subtitles([cue]))
print(encoded)
// Output:
// ID,Speaker,Start (s),Duration (s),Text
// 1,Narrator,30.0,5.0,Custom format example

```

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

### Parse Subtitles from String Content in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Parses subtitle content directly from a string when the content is already in memory. It requires the subtitle content string and an expected file extension to guide parsing. The output is a Subtitles object.

```swift
import SwiftSubtitles

let srtContent = """
1
00:05:00,400 --> 00:05:15,300
This is an example of a subtitle.

2
00:05:16,400 --> 00:05:25,300
This is an example of
a subtitle - 2nd subtitle.
"""

let subtitles = try Subtitles(content: srtContent, expectedExtension: "srt")

print("Cue count: (subtitles.cues.count)")  // Output: Cue count: 2
print("First cue text: (subtitles.cues[0].text)")  // Output: First cue text: This is an example of a subtitle.
print("Second cue text: (subtitles.cues[1].text)")  // Output: Second cue text: This is an example of\na subtitle - 2nd subtitle.

```

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

### Using Specific Coders (SRT, VTT, SBV) in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Demonstrates direct usage of SRT, VTT, and SBV coders for decoding and encoding subtitle data. It shows how to instantiate coders, decode string data into subtitle objects, and access cue information. The SBV coder is also shown for round-trip testing.

```swift
import SwiftSubtitles

// SRT Coder
let srtCoder = Subtitles.Coder.SRT()
let srtData = """
1
00:02:16,612 --> 00:02:19,376
Senator, we're making
our final approach into Coruscant.

2
00:02:19,482 --> 00:02:21,609
Very good, Lieutenant.
"""
let srtSubtitles = try srtCoder.decode(srtData)
print("SRT cues: \(srtSubtitles.cues.count)")  // Output: SRT cues: 2

// VTT Coder with speaker tags
let vttCoder = Subtitles.Coder.VTT()
let vttData = """
WEBVTT

cue-1
00:00:05.000 --> 00:00:10.000
<v Alice>Hello, how are you?

cue-2
00:00:12.000 --> 00:00:15.000
<v Bob>I'm doing great, thanks!
"""
let vttSubtitles = try vttCoder.decode(vttData)
print("VTT cue 1 speaker: \(vttSubtitles.cues[0].speaker ?? "none")")  // Output: VTT cue 1 speaker: Alice
print("VTT cue 2 speaker: \(vttSubtitles.cues[1].speaker ?? "none")")  // Output: VTT cue 2 speaker: Bob

// SBV Coder (SubViewer format)
let sbvCoder = Subtitles.Coder.SBV()
let roundTrip = try sbvCoder.encode(subtitles: srtSubtitles)
let decoded = try sbvCoder.decode(roundTrip)
print("Round-trip successful: \(decoded.cues.count == srtSubtitles.cues.count)")  // Output: Round-trip successful: true

```

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

### Convert Subtitle Formats in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Demonstrates converting subtitles between different formats like SRT and VTT using the SwiftSubtitles library. It shows how to decode content from one format and encode it into another, including specifying text encoding.

```swift
import SwiftSubtitles

// Convert SRT to VTT
let srtContent = """
1
00:00:05,000 --> 00:00:10,000
Hello, world!

2
00:00:12,000 --> 00:00:18,000
Welcome to SwiftSubtitles.
"""

// Decode from SRT
let subtitles = try Subtitles(content: srtContent, expectedExtension: "srt")

// Encode to VTT
let vttContent = try Subtitles.encode(subtitles, fileExtension: "vtt")
print(vttContent)
// Output:
// WEBVTT
//
//
// 00:00:05.000 --> 00:00:10.000
// Hello, world!
// ...

// Encode to CSV
let csvContent = try Subtitles.encode(subtitles, fileExtension: "csv")
print(csvContent)
// Output:
// No.,Timecode In,Timecode Out,Subtitle
// 1,00:00:05:000,00:00:10:000,Hello, world!
// 2,00:00:12:000,00:00:18:000,Welcome to SwiftSubtitles.

// Encode to Data with specific encoding
let utf16Data = try Subtitles.encode(subtitles, fileExtension: "srt", encoding: .utf16)
print("Data size: (utf16Data.count) bytes")  // Output: Data size: ~200 bytes
```

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

### Query Subtitle Cues with SwiftSubtitles

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Demonstrates how to query and manipulate subtitle cues using the SwiftSubtitles library. This includes finding cues at specific times, checking cue durations, and accessing first/last cues. It requires the SwiftSubtitles framework.

```swift
import SwiftSubtitles

let cues = [
    Subtitles.Cue(position: 1, startTimeInSeconds: 5.0, endTimeInSeconds: 10.0, text: "First"),
    Subtitles.Cue(position: 2, startTimeInSeconds: 12.0, endTimeInSeconds: 18.0, text: "Second"),
    Subtitles.Cue(position: 3, startTimeInSeconds: 20.0, endTimeInSeconds: 25.0, text: "Third"),
]
let subtitles = Subtitles(cues)

// Find cue containing a specific time
if let cue = subtitles.firstCue(containing: 7.5) {
    print("Found cue at 7.5s: (cue.text)")  // Output: Found cue at 7.5s: First
}

// Find next cue after a time
if let nextIndex = subtitles.nextCueIndex(for: 11.0) {
    print("Next cue index after 11s: (nextIndex)")  // Output: Next cue index after 11s: 1
}

// Get cue type result (inside cue or between cues)
if let result = subtitles.cueType(for: 15.0) {
    print("Inside cue: (result.isInsideCue), index: (result.cueIndex)")  // Output: Inside cue: true, index: 1
}

// Access first and last cues
print("First cue: (subtitles.firstCue?.text ?? "none")")  // Output: First cue: First
print("Last cue: (subtitles.lastCue?.text ?? "none")")  // Output: Last cue: Third

// Check if cue contains time
let cue = cues[0]
print("Cue contains 7.5s: (cue.contains(timeInSeconds: 7.5))")  // Output: Cue contains 7.5s: true
print("Cue duration: (cue.duration) seconds")  // Output: Cue duration: 5.0 seconds
```

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

### Load Subtitles in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Demonstrates how to load subtitle files into the SwiftSubtitles library. It supports loading from a file URL with a specified encoding or directly from string content, inferring the format from an expected file extension. This is the initial step for any subtitle processing task.

```swift
import Subtitles

// Load from file URL
if let url = URL(string: "path/to/your/subtitles.srt") {
    do {
        let subtitles = try Subtitles(fileURL: url, encoding: .utf8)
        print("Successfully loaded subtitles: \(subtitles.cues.count) cues")
    } catch {
        print("Error loading subtitles from URL: \(error)")
    }
}

// Load from content string
let subtitleContent = "1\n00:00:01,000 --> 00:00:03,000\nHello, world!\n\n2\n00:00:04,000 --> 00:00:06,000\nThis is a subtitle."
let subtitlesFromString = Subtitles(content: subtitleContent, expectedExtension: "srt")
print("Successfully loaded subtitles from string: \(subtitlesFromString.cues.count) cues")
```

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

### Load Subtitles from File in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Loads subtitle files using automatic format detection based on file extension. The library handles text encoding and BOM characters automatically. It takes a file URL and encoding as input and returns a Subtitles object.

```swift
import SwiftSubtitles

// Load from file URL with automatic format detection
let fileURL = URL(fileURLWithPath: "/path/to/subtitles.srt")
let subtitles = try Subtitles(fileURL: fileURL, encoding: .utf8)

// Access all cues
print("Total cues: (subtitles.cues.count)")
for cue in subtitles.cues {
    print("[\(cue.startTime.text) --> (cue.endTime.text)] \(cue.text)")
}
// Output:
// Total cues: 3
// [00:00:05.400 --> 00:00:15.300] This is the first subtitle.
// [00:00:16.400 --> 00:00:25.300] This is the second subtitle.
// [00:00:30.000 --> 00:00:35.500] This is the third subtitle.

```

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

### Working with Time Values in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Explains the functionality of the `Subtitles.Time` structure for precise time manipulation. It covers creating time instances from components or seconds, performing arithmetic operations like addition and subtraction, comparing time values, and accessing individual time components (hour, minute, second, millisecond).

```swift
import SwiftSubtitles

// Create time from components
let time1 = Subtitles.Time(hour: 1, minute: 30, second: 45, millisecond: 500)
print("Time text: \(time1.text)")  // Output: Time text: 01:30:45.500
print("Seconds: \(time1.timeInSeconds)")  // Output: Seconds: 5445.5

// Create time from seconds
let time2 = Subtitles.Time(timeInSeconds: 3661.25)
print("From seconds: \(time2.text)")  // Output: From seconds: 01:01:01.250

// Time arithmetic
let shifted = time1 + 10.5  // Add 10.5 seconds
print("Shifted: \(shifted.text)")  // Output: Shifted: 01:30:56.000

let earlier = time1 - 45.5  // Subtract 45.5 seconds (clamps to 0)
print("Earlier: \(earlier.text)")  // Output: Earlier: 01:30:00.000

// Time comparison
let timeA = Subtitles.Time(minute: 5)
let timeB = Subtitles.Time(minute: 10)
print("A < B: \(timeA < timeB)")  // Output: A < B: true

// Access components
print("Hour: \(time1.hour), Minute: \(time1.minute), Second: \(time1.second), MS: \(time1.millisecond)")
// Output: Hour: 1, Minute: 30, Second: 45, MS: 500

```

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

### Handle Subtitle Errors in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Illustrates how to catch and handle various errors that can occur during subtitle file parsing and encoding using Swift's `do-catch` blocks. It covers specific error types like unsupported file types and invalid time formats.

```swift
import SwiftSubtitles

// SubTitlesError cases:
// - .unsupportedFileType(String) - Unknown file extension
// - .invalidFile - File format is corrupted
// - .invalidEncoding - Text encoding mismatch
// - .invalidPosition(Int) - Position value cannot be parsed
// - .invalidTime(Int) - Time format is invalid
// - .missingText(Int) - Cue text is missing
// - .coderGeneratesBinaryContent - Coder doesn't support text output
// - .coderDoesntSupportEncoding - Coder is read-only

// Example: Handling unsupported file types
do {
    let subtitles = try Subtitles(content: "some content", expectedExtension: "xyz")
} catch SubTitlesError.unsupportedFileType(let ext) {
    print("Unsupported extension: (ext)")  // Output: Unsupported extension: xyz
} catch {
    print("Other error: (error)")
}

// Example: Handling invalid SRT format
do {
    let invalidSrt = """
1
invalid-time-format
Some text
"""
    let subtitles = try Subtitles(content: invalidSrt, expectedExtension: "srt")
} catch SubTitlesError.invalidTime(let line) {
    print("Invalid time at line: (line)")  // Output: Invalid time at line: 1
} catch SubTitlesError.invalidFile {
    print("Invalid file format")
} catch {
    print("Error: (error)")
}

// Example: Safe decoding with fallback
func safeLoadSubtitles(from content: String, format: String) -> Subtitles {
    do {
        return try Subtitles(content: content, expectedExtension: format)
    } catch {
        print("Failed to load: (error)")
        return Subtitles.empty
    }
}
```

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

### Sort and Normalize Subtitles in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Demonstrates how to sort subtitle cues by time or position and normalize position values to sequential integers. This is useful for ensuring consistent subtitle ordering and presentation.

```swift
import SwiftSubtitles

let cues = [
    Subtitles.Cue(position: 5, startTimeInSeconds: 30.0, endTimeInSeconds: 35.0, text: "Third"),
    Subtitles.Cue(position: 1, startTimeInSeconds: 10.0, endTimeInSeconds: 15.0, text: "First"),
    Subtitles.Cue(position: 3, startTimeInSeconds: 20.0, endTimeInSeconds: 25.0, text: "Second"),
]
let subtitles = Subtitles(cues)

// Note: Subtitles are automatically sorted by start time on creation
print("First by time: (subtitles.cues[0].text)")  // Output: First by time: First

// Sort by position value
let positionSorted = subtitles.positionSorted
print("First by position: (positionSorted.cues[0].text)")  // Output: First by position: First

// Reset positions to sequential values (1, 2, 3, ...)
let normalized = subtitles.setIncrementingPositionValues()
print("Normalized positions: (normalized.cues.map { $0.position ?? 0 })")  // Output: Normalized positions: [1, 2, 3]

// Extract all text from cues
let allText = subtitles.text
print("All text: (allText)")  // Output: All text: ["First", "Second", "Third"]

// Get unique speakers (if any)
let speakers = subtitles.uniqueSpeakers
print("Speakers: (speakers)")  // Output: Speakers: []
```

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

### Validate and Sanitize Subtitles with SwiftSubtitles

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Explains how to validate subtitle data and remove invalid or empty cues using the SwiftSubtitles library to ensure clean output. This includes checking for negative times, zero duration, and empty text. Requires the SwiftSubtitles framework.

```swift
import SwiftSubtitles

let cues = [
    Subtitles.Cue(position: 1, startTimeInSeconds: 5.0, endTimeInSeconds: 10.0, text: "Valid cue"),
    Subtitles.Cue(position: 2, startTimeInSeconds: 15.0, endTimeInSeconds: 15.0, text: "Zero duration"),  // Invalid
    Subtitles.Cue(position: 3, startTimeInSeconds: 20.0, endTimeInSeconds: 25.0, text: ""),  // Empty text
    Subtitles.Cue(position: 4, startTimeInSeconds: 30.0, endTimeInSeconds: 35.0, text: "Another valid"),
]
let subtitles = Subtitles(cues)

// Find indexes of invalid cues (negative times or zero duration)
let invalidIndexes = subtitles.indexesOfInvalidCues()
print("Invalid cue indexes: (invalidIndexes)")  // Output: Invalid cue indexes: [1]

// Remove invalid cues
let validOnly = subtitles.removingInvalidCues()
print("Valid cues count: (validOnly.cues.count)")  // Output: Valid cues count: 3

// Remove empty cues (empty text)
let nonEmpty = subtitles.removingEmptyCues()
print("Non-empty cues count: (nonEmpty.cues.count)")  // Output: Non-empty cues count: 3

// Find zero-length cues
let zeroLength = subtitles.cuesOfZeroLength()
print("Zero-length cues: (zeroLength.count)")  // Output: Zero-length cues: 1

// Check individual cue validity
print("Cue 1 valid: (cues[0].isValidTime)")  // Output: Cue 1 valid: true
print("Cue 2 valid: (cues[1].isValidTime)")  // Output: Cue 2 valid: false
```

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

### Encode Subtitles with File Extension or Explicit Coder (Swift)

Source: https://github.com/dagronf/swiftsubtitles/blob/main/README.md

Demonstrates creating subtitle cues and then encoding them into a string. Encoding can be done by specifying the desired file extension (e.g., 'srt') or by explicitly providing a coder instance (e.g., VTT coder).

```swift
let cue1 = Subtitles.Cue(
	position: 1,
	startTime: Subtitles.Time(minute: 10),
	endTime: Subtitles.Time(minute: 11),
	text: "점점 더 많아지는\n시민들의 성난 목소리로..."
)

let cue2 = Subtitles.Cue(
	position: 2,
	startTime: Subtitles.Time(minute: 13, second: 5),
	endTime: Subtitles.Time(minute: 15, second: 10, millisecond: 101),
	text: "Second entry"
)

let subtitles = Subtitles([cue1, cue2])

// Encode based on the subtitle file extension
let content = try Subtitles.encode(subtitles, fileExtension: "srt")

// Encode using an explicit coder
let coder = Subtitles.Coder.VTT()
let content2 = try coder.encode(subtitles: subtitles)
```

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

### Decode and Encode Subtitles with Specific Coder (Swift)

Source: https://github.com/dagronf/swiftsubtitles/blob/main/README.md

Allows for manual instantiation of a specific subtitle coder to decode subtitle content from a string. It also demonstrates encoding subtitle data back into a string using the same coder.

```swift
let subtitleContent = ...
let coder = Subtitles.Coder.SBV()
let subtitles = try coder.decode(subtitleContent)
...
let encodedContent = try coder.encode(subtitles: subtitles)
```

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

### Shift Subtitle Timings with SwiftSubtitles

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Provides functionality to shift all subtitle timings forward or backward by a specified duration using the SwiftSubtitles library. This is useful for synchronization adjustments. It requires the SwiftSubtitles framework.

```swift
import SwiftSubtitles

let cues = [
    Subtitles.Cue(position: 1, startTimeInSeconds: 10.0, endTimeInSeconds: 15.0, text: "First"),
    Subtitles.Cue(position: 2, startTimeInSeconds: 20.0, endTimeInSeconds: 25.0, text: "Second"),
]
let subtitles = Subtitles(cues)

// Shift all cues forward by 5 seconds
let shiftedForward = subtitles.timeShifting(by: 5.0)
print("First cue start after +5s: (shiftedForward.cues[0].startTimeInSeconds)")  // Output: First cue start after +5s: 15.0

// Shift all cues backward by 3 seconds
let shiftedBack = subtitles.timeShifting(by: -3.0)
print("First cue start after -3s: (shiftedBack.cues[0].startTimeInSeconds)")  // Output: First cue start after -3s: 7.0

// Shift cues starting from a specific time
let shiftedFromTime = subtitles.timeShifting(by: 10.0, at: 15.0)
print("Second cue after shift from 15s: (shiftedFromTime.cues[1].startTimeInSeconds)")  // Output: Second cue after shift from 15s: 30.0

// Individual cue time shifting
let cue = cues[0]
let shiftedCue = cue.timeshifting(by: 2.5)
print("Cue shifted by 2.5s: (shiftedCue.startTimeInSeconds) - (shiftedCue.endTimeInSeconds)")
// Output: Cue shifted by 2.5s: 12.5 - 17.5
```

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

### Export Subtitles in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Illustrates how to export subtitle data from the SwiftSubtitles library into various formats. The `encode` method allows specifying the desired file extension, and format-specific coders can be used for more advanced control. This is essential for saving processed subtitles.

```swift
import Subtitles

// Assume 'subtitles' is an existing Subtitles object
let subtitles = Subtitles()
// Add some cues to the subtitles object...

// Export to SRT format
if let srtData = Subtitles.encode(subtitles, fileExtension: "srt") {
    do {
        try srtData.write(to: URL(string: "path/to/output/subtitles.srt")!, options: .atomic)
        print("Successfully exported to SRT.")
    } catch {
        print("Error writing SRT file: \(error)")
    }
}

// Export to VTT format
if let vttData = Subtitles.encode(subtitles, fileExtension: "vtt") {
    do {
        try vttData.write(to: URL(string: "path/to/output/subtitles.vtt")!, options: .atomic)
        print("Successfully exported to VTT.")
    } catch {
        print("Error writing VTT file: \(error)")
    }
}
```

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

### Manipulate Subtitle Cues in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Shows how to modify subtitle data using query and transformation methods provided by the SwiftSubtitles library. This includes filtering, mapping, and applying time shifts to subtitle cues. These operations are crucial for editing and synchronizing subtitle tracks.

```swift
import Subtitles

// Assume 'subtitles' is an existing Subtitles object loaded previously
let subtitles = Subtitles()
// Add some cues to the subtitles object...

// Example: Filter cues that start after a certain time
let startTime = 5.0 // seconds
let filteredCues = subtitles.cues.filter { $0.startTime >= startTime }
print("Filtered cues: \(filteredCues.count)")

// Example: Shift all cues forward by 2 seconds
let timeShift: TimeInterval = 2.0
let shiftedSubtitles = subtitles.shifted(by: timeShift)
print("Shifted subtitles created.")

// Example: Transform cue text (e.g., convert to uppercase)
let uppercasedSubtitles = subtitles.map { cue in
    var newCue = cue
    newCue.text = newCue.text.uppercased()
    return newCue
}
print("Mapped cues to uppercase.")
```

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

### CSV Subtitle Decoding and Encoding Configuration (Swift)

Source: https://github.com/dagronf/swiftsubtitles/blob/main/README.md

Illustrates how the CSV coder in Swift Subtitles handles decoding and encoding, including support for RFC 4180 compliance and configurable column order. It mentions the use of the TinyCSV library for these operations.

```swift
// Example of configuring CSV coder (actual code not provided in source, conceptual)
// let coder = Subtitles.Coder.CSV(columnOrder: [.startTime, .text, .endTime, .position])
// let subtitles = try coder.decode(csvContent)
// let encodedContent = try coder.encode(subtitles: subtitles)
```

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

### Encode Subtitles to String in Swift

Source: https://context7.com/dagronf/swiftsubtitles/llms.txt

Exports subtitle data to various string formats using file extension-based encoding or explicit coder instances. It takes a Subtitles object and a file extension or a specific coder as input, returning the encoded string content.

```swift
import SwiftSubtitles

let cue1 = Subtitles.Cue(
    position: 1,
    startTime: Subtitles.Time(minute: 0, second: 5),
    endTime: Subtitles.Time(minute: 0, second: 10),
    text: "Hello, world!"
)

let cue2 = Subtitles.Cue(
    position: 2,
    startTime: Subtitles.Time(minute: 0, second: 12),
    endTime: Subtitles.Time(minute: 0, second: 18),
    text: "This is SwiftSubtitles."
)

let subtitles = Subtitles([cue1, cue2])

// Encode using file extension
let srtContent = try Subtitles.encode(subtitles, fileExtension: "srt")
print(srtContent)
// Output:
// 1
// 00:00:05,000 --> 00:00:10,000
// Hello, world!
//
// 2
// 00:00:12,000 --> 00:00:18,000
// This is SwiftSubtitles.

// Encode using explicit coder
let vttCoder = Subtitles.Coder.VTT()
let vttContent = try vttCoder.encode(subtitles: subtitles)
print(vttContent)
// Output:
// WEBVTT
//
//
// 00:00:05.000 --> 00:00:10.000
// Hello, world!
//
//
// 00:00:12.000 --> 00:00:18.000
// This is SwiftSubtitles.

```

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

### Decode Subtitles by File URL (Swift)

Source: https://github.com/dagronf/swiftsubtitles/blob/main/README.md

Decodes subtitle content directly from a file URL. The library automatically determines the subtitle format based on the file extension. It iterates through the decoded cues for further processing.

```swift
let subtitles = try Subtitles(fileURL: <some file url>)
subtitles.cues.forEach {
	// Do something with 'cue'
}
```

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