expo-video-subtitle 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -7,6 +7,46 @@ Changes inherited from the upstream base version are not repeated here — see t
 [upstream changelog](https://github.com/expo/expo/blob/main/packages/expo-video/CHANGELOG.md)
 for the history of everything that isn't subtitle related.
 
+## 0.6.0
+
+### Fixed
+
+- **ASS dialogue keeps working with `bottomOffset` and with cue stacking again (Android).** Media3's
+  `SsaParser` calls `setLine` and `setPosition` on *every* cue, including the bottom-centre dialogue
+  the author placed nothing on. `SubtitlePainter` applies `bottomPaddingFraction` only to cues whose
+  `line` is unset, so `SubtitleSource.bottomOffset` silently stopped moving anything on an `.ass`
+  track, and `StackingSubtitleParser` treated every cue as deliberately placed and left simultaneous
+  speakers drawing on top of each other.
+
+  A new `SsaCueNormalizer` clears the placement Media3 filled in. Recognising it is exact rather
+  than a guess: the values are a pure function of the cue's anchors, so a cue matching both defaults
+  for the bottom-centre anchors is precisely a cue with no positioning tag. Anything the author did
+  place — `\an8`, `\pos`, a style aligned elsewhere — keeps everything and still bypasses stacking.
+
+- **Signs keep the colours they were typeset in (Android).** The span filter dropped colour from
+  every cue so the app's own subtitle style would win, which is right for dialogue and wrong for a
+  sign: typesetting is drawn onto the artwork in colours chosen to sit on it, and the dark lettering
+  on the white placards in Jujutsu Kaisen S3E3 became white-on-white. Cues an ASS track positions
+  itself now keep their appearance; unpositioned dialogue still loses its own and follows the
+  viewer's settings. Only ASS opts in — it is the one format where positioning reliably means
+  "sign" rather than a cue setting on ordinary dialogue.
+
+- **Typesetters' working notes stay hidden.** A script ships its production notes on a style that
+  renders nothing: JJK S3E3 carries `Style: f0ld3r-invisible` with `Fontsize 0` and every colour
+  `&HFF……`, holding 158 events of "--mahito", "#1", "check in frame 6212". libass honours both
+  signals. Media3 turns a transparent primary colour into a `ForegroundColorSpan` with alpha 0,
+  which the span filter then strips, so the note came back in the viewer's colour at the viewer's
+  size; the iOS converter never read either field, and WebVTT cannot express opacity anyway. Events
+  on such a style are now dropped on both platforms, before anything can make them visible.
+
+### Known limitations
+
+- Sign **font size** is still the app's, not the script's. Media3 does read `Fontsize` into
+  `Cue.textSize`, but the filter clears it so the two subtitle views measure the same glyphs; giving
+  it back to signs needs the rounded-background view checked on a device first.
+- Blur, borders, shadows, rotation and `\t` animation are still dropped. Matching libass output
+  exactly needs libass, not Media3.
+
 ## 0.5.0
 
 ### Added

package/FORK.md

@@ -27,7 +27,8 @@ Measured against the published `expo-video@56.1.4` tarball. `+`/`-` are added/re
 | `android/…/utils/SubtitleSpanFilter.kt` | 135 | Strips colour, size, family and weight from every cue of every format, keeping italic/underline/strikethrough and all positioning, plus `FilteringSubtitleParser` which applies it to whatever a delegate emits. **Load-bearing fact, verified against Media3 1.9.0 bytecode:** `SubtitleViewUtils.removeAllEmbeddedStyling` touches only `clearWindowColor`, `getText`/`setText` and `setTextSize` — never `line`, `position` or `textAlignment`. That is why the filter can live in the parser and the view flag can stay on; if an upstream sync changes it, this whole design has to be revisited. Uses an **allowlist**, because a denylist misses `TextAppearanceSpan` (colour + size + family in one span). `StyleSpan` needs a rewrite rather than a keep/drop: `BOLD_ITALIC` has to come back as plain `ITALIC` over the same range. |
 | `android/…/records/SubtitleSource.kt` | 63 | Record → `MediaItem.SubtitleConfiguration` + MIME resolution. |
 | `android/…/records/SubtitleStyle.kt` | 152 | Record → `CaptionStyleCompat`; hex colour parsing; font-family resolution (`res/font` → `ReactFontManager`); the `applyEmbeddedStyles` flag, which `SubtitleUtils` reads directly rather than `toCaptionStyle` and which defaults to `true` since 0.5.0. |
-| `android/…/utils/StackingSubtitleParser.kt` | 308 | `SubtitleParser` for SubRip that segments the cue timeline and merges simultaneous cues into one stacked block, plus the `SubtitleParser.Factory` that routes SubRip to it and wraps every parser in `FilteringSubtitleParser`. SSA/ASS is deliberately not stacked: `SsaParser` sets both `line` and `position` on every cue, so they would all take the passthrough branch anyway. Assigns each cue a vertical slot it keeps for its whole time on screen — a finished cue's line is held blank (`\u200B`) so the cues above it do not drop. Merges through a `SpannableStringBuilder` so cue spans survive. |
+| `android/…/utils/StackingSubtitleParser.kt` | 342 | `SubtitleParser` that segments the cue timeline and merges simultaneous **unpositioned** cues into one stacked block, plus the `SubtitleParser.Factory` that routes SubRip and ASS/SSA to it and wraps every parser in `FilteringSubtitleParser`. ASS gets there through `SsaCueNormalizer` as the `prepare` step — without it `SsaParser` sets both `line` and `position` on every cue and they would all take the passthrough branch. Assigns each cue a vertical slot it keeps for its whole time on screen — a finished cue's line is held blank (`\u200B`) so the cues above it do not drop. Merges through a `SpannableStringBuilder` so cue spans survive. |
+| `android/…/utils/SsaCueNormalizer.kt` | 93 | Clears the `line`/`position` Media3's `SsaParser` fills in on cues the ASS author never placed, so `bottomOffset` and cue stacking work on `.ass` the way they already do on `.srt`. The test is exact rather than heuristic: those values are a pure function of the cue's anchors, so matching both defaults for the bottom-centre anchors *is* "no positioning tag". Also drops events on a style the author made invisible (`Fontsize 0`, or a primary colour whose inverted alpha byte is `FF`) — that is where typesetters park working notes, and nothing downstream can carry "invisible". |
 | `android/…/utils/RoundedSubtitleBackground.kt` | 352 | Draws `subtitleStyle.backgroundRadius` as rounded boxes, which Media3 cannot do at all: it paints `backgroundColor` as a framework `BackgroundColorSpan` and `windowColor` with `canvas.drawRect`, neither takes a radius, and `SubtitlePainter`/`CanvasSubtitleOutput` are package-private final while `SubtitleView` is final. A second `SubtitleView` is inserted behind `PlayerView`'s own, fed from `Player.Listener.onCues`, drawing a `LineBackgroundSpan` per line. **Its `EDGE_TYPE_NONE` is load-bearing** — `SubtitlePainter` copies the cue text for an edge pass and draws both layouts when the edge type is outline/raised/depressed, which would paint the box twice and darken a semi-transparent colour. State hangs off the view's `tag`, never a map in the companion object; see the `find` KDoc for why even a `WeakHashMap` leaks here. |
 | `FORK.md`, `LICENSE` | — | This guide; MIT licence (upstream copyright preserved). |
 | `eslint.config.js` | 4 | Verbatim copy of `expo-module-scripts/templates/eslint.config.js`. **Recreate it if a sync drops it** — `expo-module configure` treats it as an *optional* template and only syncs it when it already exists, so without this file `npm run lint` dies with "ESLint couldn't find an eslint.config.js". |

package/android/src/main/java/expo/modules/video/utils/SsaCueNormalizer.kt

@@ -0,0 +1,93 @@
+package expo.modules.video.utils
+
+import android.graphics.Color
+import android.text.Spanned
+import android.text.style.ForegroundColorSpan
+import androidx.annotation.OptIn
+import androidx.media3.common.text.Cue
+import androidx.media3.common.util.UnstableApi
+import kotlin.math.abs
+
+/**
+ * Undoes two things Media3's `SsaParser` does to every ASS cue, so the rest of this package can
+ * treat an `.ass` track the way it treats every other format.
+ *
+ * ### Dialogue gets its position taken back off
+ *
+ * `SsaParser.createCue` ends with an `else` branch that runs for every cue *without* a `\pos` or
+ * `\move`: it calls `setPosition` and `setLine` with values derived purely from the cue's
+ * alignment. So an ordinary bottom-centre dialogue line — the overwhelming majority of a subtitle
+ * file — arrives carrying `line = 0.95` and `position = 0.5` even though the author placed nothing.
+ *
+ * Two features break on that. `SubtitlePainter` applies `bottomPaddingFraction` only to cues whose
+ * `line` is unset, so `SubtitleSource.bottomOffset` (the app's `subtitle_offset_percent`, used to
+ * lift softsubs clear of burnt-in hardsubs) silently stops moving anything. And
+ * [StackingSubtitleParser] treats a positioned cue as deliberately placed and passes it through
+ * unstacked, so two simultaneous speakers draw on top of each other.
+ *
+ * Recognising "the parser filled this in" is exact rather than a guess: the values are a pure
+ * function of the anchors, so a cue matching *both* defaults for the bottom-centre anchors is
+ * precisely a cue that had no positioning tag. Clearing them puts an ASS dialogue cue in the same
+ * shape as a SubRip one, which is the shape both features already work on.
+ *
+ * A cue the author did place — `\an8`, `\pos`, a style aligned anywhere but bottom-centre — fails
+ * the check and keeps everything. That is the signs-and-typesetting case, and it must not move.
+ *
+ * ### Cues the author made invisible are dropped
+ *
+ * Typesetters keep their working notes in the script on a style that renders nothing: JJK S3E3
+ * ships `Style: f0ld3r-invisible` with `Fontsize 0` and every colour `&HFF……`, holding 158 events
+ * of production notes ("--mahito", "#1", "check in frame 6212").
+ *
+ * libass honours both signals and shows nothing. Media3 turns the fully transparent primary colour
+ * into a `ForegroundColorSpan` with alpha 0 — and [SubtitleSpanFilter] then strips colour spans,
+ * because the app owns the subtitle colour. The note would come back in the viewer's own colour, at
+ * the viewer's own size, on screen. Dropping the cue here, before any of that, is the only place
+ * the alpha still means what the author meant.
+ */
+@OptIn(UnstableApi::class)
+internal object SsaCueNormalizer {
+  /** `SsaParser.DEFAULT_MARGIN`. Kept in sync by [sitsWhereTheParserPutIt]'s test. */
+  private const val DEFAULT_MARGIN = 0.05f
+
+  /** The values are computed, not parsed, so they compare exactly; this only guards float drift. */
+  private const val EPSILON = 0.0001f
+
+  fun normalize(cue: Cue): Cue? {
+    if (isInvisible(cue)) return null
+    if (!sitsWhereTheParserPutIt(cue)) return cue
+
+    return cue.buildUpon()
+      .setLine(Cue.DIMEN_UNSET, Cue.LINE_TYPE_FRACTION)
+      .setPosition(Cue.DIMEN_UNSET)
+      .build()
+  }
+
+  /**
+   * True when the cue's placement is exactly what `SsaParser` computes for the bottom-centre
+   * anchors, which is to say the author placed nothing.
+   */
+  private fun sitsWhereTheParserPutIt(cue: Cue): Boolean =
+    cue.lineType == Cue.LINE_TYPE_FRACTION &&
+      cue.lineAnchor == Cue.ANCHOR_TYPE_END &&
+      cue.positionAnchor == Cue.ANCHOR_TYPE_MIDDLE &&
+      abs(cue.line - (1f - DEFAULT_MARGIN)) < EPSILON &&
+      abs(cue.position - 0.5f) < EPSILON
+
+  /**
+   * Either of the two ways an ASS style says "draw nothing": a fully transparent primary colour, or
+   * a zero font size. Both have to cover the whole cue — a transparent run *inside* a line is a
+   * typesetting effect, not a hidden line.
+   */
+  private fun isInvisible(cue: Cue): Boolean {
+    val text = cue.text ?: return false
+    if (cue.textSize == 0f) return true
+    if (text !is Spanned || text.isEmpty()) return false
+
+    return text.getSpans(0, text.length, ForegroundColorSpan::class.java).any { span ->
+      Color.alpha(span.foregroundColor) == 0 &&
+        text.getSpanStart(span) == 0 &&
+        text.getSpanEnd(span) == text.length
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/utils/StackingSubtitleParser.kt

@@ -24,8 +24,8 @@ import androidx.media3.extractor.text.subrip.SubripParser
 internal const val HELD_SLOT_PLACEHOLDER = '\u200B'
 
 /**
- * A [SubtitleParser] for SubRip (`.srt`) that lays out simultaneous cues as a single stacked block
- * instead of drawing them on top of each other.
+ * A [SubtitleParser] that lays out simultaneous unpositioned cues as a single stacked block instead
+ * of drawing them on top of each other.
  *
  * ### Why this is needed
  *
@@ -53,14 +53,25 @@ internal const val HELD_SLOT_PLACEHOLDER = '\u200B'
  * A cue also keeps the same line for its whole time on screen. Because the block is anchored at its
  * bottom, a cue would otherwise drop down a line the moment the cue *below* it ended — moving the
  * text the viewer is reading at that moment. The vacated line is therefore held as blank height
- * until a later cue reclaims it; see [StackingSubripParser.updateSlots].
+ * until a later cue reclaims it; see [StackingSubtitleParser.updateSlots].
  *
- * Cues that *do* carry explicit positioning (SubRip's `{\anN}` tags) are passed through untouched —
- * they were placed deliberately and must not be merged.
+ * Cues that *do* carry explicit positioning (SubRip's `{\anN}` tags, an ASS `\pos` or `\an`) are
+ * passed through untouched — they were placed deliberately and must not be merged.
+ *
+ * ASS reaches this through [SsaCueNormalizer] as the `prepare` step, which is what makes the
+ * paragraph above true for it: Media3 positions every SSA cue, so without that step every one of
+ * them would take the passthrough branch. See [StackingSsaParser].
  */
 @OptIn(UnstableApi::class)
-class StackingSubripParser : SubtitleParser {
-  private val delegate = SubripParser()
+open class StackingSubtitleParser(
+  private val delegate: SubtitleParser,
+  /**
+   * Applied to every cue as it arrives, before any overlap is worked out. Returning null drops the
+   * cue. [SsaCueNormalizer] uses this to hand back the cues an ASS author never placed, so they
+   * reach the slot layout below instead of the passthrough branch.
+   */
+  private val prepare: (Cue) -> Cue? = { it },
+) : SubtitleParser {
 
   // Every emitted segment is a complete description of what should be on screen for its interval,
   // so segments replace each other rather than being merged by the renderer.
@@ -84,7 +95,8 @@ class StackingSubripParser : SubtitleParser {
       val startUs = cuesWithTiming.startTimeUs
       val endUs = resolveEndUs(cuesWithTiming)
       for (cue in cuesWithTiming.cues) {
-        entries.add(Entry(cue, startUs, endUs, entries.size))
+        val prepared = prepare(cue) ?: continue
+        entries.add(Entry(prepared, startUs, endUs, entries.size))
       }
     }
 
@@ -274,17 +286,26 @@ class StackingSubripParser : SubtitleParser {
   }
 }
 
+/** SubRip, which Media3 already leaves unpositioned. */
+@OptIn(UnstableApi::class)
+class StackingSubripParser : StackingSubtitleParser(SubripParser())
+
 /**
- * Routes SubRip through [StackingSubripParser] so simultaneous cues stack, delegates every other
- * subtitle format to Media3's default handling, and wraps the result in [FilteringSubtitleParser] so
- * the appearance a track asks for never overrides the app's own subtitle style.
+ * ASS and SSA, via [SsaCueNormalizer].
  *
- * SSA and ASS are deliberately NOT stacked. `SsaParser` gives every cue both a `line` and a
- * `position`, so [StackingSubripParser.hasExplicitPosition] would send all of them down the
- * passthrough branch anyway, and its merge deliberately leaves `line` unset, which would fight
- * `\an` and `\pos`. The consequence is real and known: Media3 does no collision avoidance between
- * positioned cues, so two simultaneous `\an2` dialogue lines overlap on Android where libass would
- * stack them.
+ * The delegate is built by the caller rather than constructed here because an SSA track muxed into
+ * a container carries its `[V4+ Styles]` header in the format's initialization data, and only
+ * `DefaultSubtitleParserFactory` knows to pass it on. A parser built without it resolves no styles.
+ */
+@OptIn(UnstableApi::class)
+class StackingSsaParser(delegate: SubtitleParser) :
+  StackingSubtitleParser(delegate, SsaCueNormalizer::normalize)
+
+/**
+ * Routes SubRip and ASS/SSA through the stacking parsers so simultaneous cues stack, delegates every
+ * other subtitle format to Media3's default handling, and wraps the result in
+ * [FilteringSubtitleParser] so the appearance a track asks for never overrides the app's own
+ * subtitle style — except for cues the track positions itself, which keep theirs.
  */
 @OptIn(UnstableApi::class)
 class ExpoVideoSubtitleParserFactory : SubtitleParser.Factory {
@@ -294,17 +315,28 @@ class ExpoVideoSubtitleParserFactory : SubtitleParser.Factory {
     format.isSubrip() || defaultFactory.supportsFormat(format)
 
   override fun getCueReplacementBehavior(format: Format): Int =
-    if (format.isSubrip()) {
+    if (format.isSubrip() || format.isSsa()) {
+      // Both stacking parsers emit whole-screen segments, whatever the delegate's own behaviour is.
       Format.CUE_REPLACEMENT_BEHAVIOR_REPLACE
     } else {
       defaultFactory.getCueReplacementBehavior(format)
     }
 
-  override fun create(format: Format): SubtitleParser =
-    FilteringSubtitleParser(
-      if (format.isSubrip()) StackingSubripParser() else defaultFactory.create(format)
+  override fun create(format: Format): SubtitleParser = when {
+    format.isSubrip() -> FilteringSubtitleParser(StackingSubripParser())
+    // Only ASS gets the positioned-cue carve-out. It is the one format where a positioned cue is
+    // reliably a sign — typeset to sit on the artwork, in colours chosen to match it — rather than
+    // dialogue that happens to carry a cue setting.
+    format.isSsa() -> FilteringSubtitleParser(
+      StackingSsaParser(defaultFactory.create(format)),
+      keepAppearanceOfPositionedCues = true,
     )
+    else -> FilteringSubtitleParser(defaultFactory.create(format))
+  }
 
   private fun Format.isSubrip(): Boolean =
     MimeTypes.APPLICATION_SUBRIP.equals(sampleMimeType, ignoreCase = true)
+
+  private fun Format.isSsa(): Boolean =
+    MimeTypes.TEXT_SSA.equals(sampleMimeType, ignoreCase = true)
 }

package/android/src/main/java/expo/modules/video/utils/SubtitleSpanFilter.kt

@@ -56,7 +56,18 @@ internal object SubtitleSpanFilter {
     else -> false
   }
 
-  fun filter(cue: Cue): Cue {
+  /**
+   * @param keepPositionedCues when true, a cue the track placed itself keeps every span it came
+   *   with. Signs are typeset onto the artwork in colours chosen to sit on it — the dark lettering
+   *   on the white placards in Jujutsu Kaisen S3E3 is the case that forced this — so repainting
+   *   them in the viewer's dialogue colour makes them unreadable rather than consistent. Dialogue
+   *   is unpositioned and still loses its appearance, which is the setting the viewer actually
+   *   controls. Only ASS passes true: it is the one format where positioning reliably means
+   *   "sign", rather than a cue setting on ordinary dialogue.
+   */
+  fun filter(cue: Cue, keepPositionedCues: Boolean = false): Cue {
+    if (keepPositionedCues && cue.isPositioned()) return cue
+
     val text = cue.text
     val hasSpans = text is Spanned
     val needsWork = hasSpans || cue.windowColorSet || cue.textSize != Cue.DIMEN_UNSET
@@ -95,18 +106,28 @@ internal object SubtitleSpanFilter {
 
     return builder.build()
   }
+
+  /**
+   * Whether the track placed this cue rather than letting the renderer put it at the bottom.
+   *
+   * For ASS this is only meaningful after [SsaCueNormalizer] has run: Media3 fills both fields in
+   * on every SSA cue, so before normalization every cue answers true.
+   */
+  private fun Cue.isPositioned(): Boolean =
+    line != Cue.DIMEN_UNSET || position != Cue.DIMEN_UNSET
 }
 
 /**
  * Applies [SubtitleSpanFilter] to every cue a delegate parser emits.
  *
  * Wrapping is deliberately the outermost layer so it also covers the merged
- * block [StackingSubripParser] produces, and so every format gets the same
+ * block [StackingSubtitleParser] produces, and so every format gets the same
  * policy for free.
  */
 @OptIn(UnstableApi::class)
 internal class FilteringSubtitleParser(
-  private val delegate: SubtitleParser
+  private val delegate: SubtitleParser,
+  private val keepAppearanceOfPositionedCues: Boolean = false,
 ) : SubtitleParser {
   // Forwarded verbatim. Getting this wrong silently changes whether consecutive
   // CuesWithTiming replace or merge: SsaParser is MERGE, StackingSubripParser
@@ -125,7 +146,7 @@ internal class FilteringSubtitleParser(
     delegate.parse(data, offset, length, outputOptions) { group ->
       output.accept(
         CuesWithTiming(
-          group.cues.map(SubtitleSpanFilter::filter),
+          group.cues.map { SubtitleSpanFilter.filter(it, keepAppearanceOfPositionedCues) },
           group.startTimeUs,
           group.durationUs
         )

package/ios/SubtitleConverterText.swift

@@ -27,6 +27,10 @@ internal extension SubtitleConverter {
       guard event.endMs > event.startMs else { continue }
 
       let style = script.styles[event.styleName]
+      // A style that draws nothing is the author hiding a working note in a script they still ship.
+      // WebVTT has no way to carry "invisible", so the note has to be dropped here or it is read.
+      if style?.invisible == true { continue }
+
       var rendered = renderAssText(
         event.text,
         defaultAlignment: style?.alignment ?? 2,
@@ -611,6 +615,8 @@ private struct AssScript {
     var alignment: Int
     var italic: Bool
     var underline: Bool
+    /// The author asked for this style to draw nothing. See `isInvisibleStyle`.
+    var invisible: Bool
   }
 
   struct Event {
@@ -678,7 +684,8 @@ private struct AssScript {
               ? (SubtitleConverter.legacyAlignment(rawAlignment) ?? 2)
               : ((1...9).contains(rawAlignment) ? rawAlignment : 2),
             italic: field("italic") == "-1",
-            underline: field("underline") == "-1"
+            underline: field("underline") == "-1",
+            invisible: Self.isInvisibleStyle(fontSize: field("fontsize"), primaryColour: field("primarycolour"))
           )
         }
 
@@ -705,6 +712,28 @@ private struct AssScript {
     if sawPlayResX && !sawPlayResY { playResY = (playResX * 3 / 4).rounded() }
   }
 
+  /// Whether a style renders nothing at all, which is how a typesetter parks working notes in a
+  /// script they still have to ship.
+  ///
+  /// Jujutsu Kaisen S3E3 carries `Style: f0ld3r-invisible` — `Fontsize 0`, every colour `&HFF……` —
+  /// holding 158 events of production notes ("--mahito", "#1", "check in frame 6212"). libass
+  /// honours both signals and draws nothing. Nothing downstream of this converter can: WebVTT
+  /// carries no per-cue opacity, and the app owns the subtitle colour anyway, so a note that
+  /// reaches a cue is a note the viewer reads.
+  ///
+  /// In ASS the alpha byte is inverted — `&HAABBGGRR` with `FF` meaning fully transparent — so the
+  /// test is the two leading hex digits after `&H`, and a six-digit colour has no alpha byte and is
+  /// therefore opaque.
+  private static func isInvisibleStyle(fontSize: String?, primaryColour: String?) -> Bool {
+    if let fontSize, let size = Double(fontSize), size <= 0 { return true }
+
+    guard var colour = primaryColour?.trimmingCharacters(in: .whitespaces) else { return false }
+    if colour.hasPrefix("&H") || colour.hasPrefix("&h") { colour = String(colour.dropFirst(2)) }
+    colour = colour.hasSuffix("&") ? String(colour.dropLast()) : colour
+    guard colour.count == 8, let alpha = UInt8(colour.prefix(2), radix: 16) else { return false }
+    return alpha == 0xFF
+  }
+
   private static func parseEvent(_ value: String, fields: [String]) -> Event? {
     // Fall back to the canonical ASS order when the section had no Format: line.
     let names = fields.isEmpty

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-video-subtitle",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "A cross-platform, performant video component for React Native and Expo with external subtitle sideloading and custom subtitle styling.",
   "keywords": [
     "expo",