@amazon/vinyl 1.2.0 → 1.2.2

package/dist/types/current/text/TextTrackRenderer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Renders a text track's cues. Injected into the player so an application can
+ * paint captions itself (as HTML) instead of relying on the browser's native
+ * `TextTrack` rendering — giving full control over styling and placement.
+ *
+ * The controller hands the renderer the DOM `TextTrack` (set to `'hidden'`, so
+ * the browser tracks cue timing but does not paint); the renderer listens for
+ * the track's active cues and draws them. See {@link HtmlTextTrackRenderer} for
+ * the built-in HTML implementation.
+ */
+export interface TextTrackRenderer {
+    /**
+     * Renders the active cues of `track`, listening for cue changes. Passing
+     * `null` clears anything rendered and detaches from the previous track.
+     */
+    setTextTrack(track: TextTrack | null): void;
+    /**
+     * Supplies the CSS bodies of the track's WebVTT `STYLE` blocks (which carry
+     * `::cue` rules), so the renderer can style cue classes. Optional — a
+     * renderer may ignore authored styles.
+     */
+    setStyles?(styles: readonly string[]): void;
+}
+//# sourceMappingURL=TextTrackRenderer.d.ts.map

package/dist/types/current/text/TextTrackRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextTrackRenderer.d.ts","sourceRoot":"","sources":["../../../../src/text/TextTrackRenderer.ts"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAAA;IAE3C;;;;OAIG;IACH,SAAS,CAAC,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAA;CAC9C"}

package/dist/types/current/text/TextTrackRenderer.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/types/current/text/VttCueStyle.d.ts

@@ -0,0 +1,41 @@
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+/**
+ * Layout style applied to each rendered WebVTT cue, mirroring the settable
+ * positioning properties of the DOM `VTTCue`. Only the properties that are set
+ * are applied; the rest keep the browser defaults.
+ *
+ * These are the WebVTT cue-box layout controls (not text color/font, which are
+ * only reachable via the non-configurable `::cue` pseudo-element). See
+ * {@link https://developer.mozilla.org/docs/Web/API/VTTCue}.
+ */
+export interface VttCueStyle {
+    /** Text alignment within the cue box. */
+    readonly align?: AlignSetting;
+    /** Line (vertical) position, as a line number/percentage or `'auto'`. */
+    readonly line?: number | AutoKeyword;
+    /** How `line` is anchored. */
+    readonly lineAlign?: LineAlignSetting;
+    /** Inline position of the cue box, as a percentage or `'auto'`. */
+    readonly position?: number | AutoKeyword;
+    /** How `position` is anchored. */
+    readonly positionAlign?: PositionAlignSetting;
+    /** Size of the cue box as a percentage of the video dimension. */
+    readonly size?: number;
+    /** Whether `line` is a line number (true) or a percentage (false). */
+    readonly snapToLines?: boolean;
+    /** Writing direction. */
+    readonly vertical?: DirectionSetting;
+}
+/**
+ * Type guard for a DOM cue that is a `VTTCue` (and so carries the WebVTT layout
+ * properties). On platforms without `VTTCue`, cues are plain `TextTrackCue`s
+ * that cannot be styled.
+ */
+export declare function isVttCue(cue: TextTrackCue): cue is VTTCue;
+/**
+ * Applies the configured layout style to a `VTTCue`, setting only the
+ * properties present in `style`.
+ */
+export declare function applyVttCueStyle(cue: VTTCue, style: VttCueStyle): void;
+export declare const vttCueStyleValidator: ObjectSchema<VttCueStyle>;
+//# sourceMappingURL=VttCueStyle.d.ts.map

package/dist/types/current/text/VttCueStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VttCueStyle.d.ts","sourceRoot":"","sources":["../../../../src/text/VttCueStyle.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAG5D;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IACxB,yCAAyC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAA;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,WAAW,CAAA;IACpC,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAA;IACrC,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,WAAW,CAAA;IACxC,kCAAkC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAA;IAC7C,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,sEAAsE;IACtE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B,yBAAyB;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAA;CACvC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,GAAG,IAAI,MAAM,CAEzD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAUtE;AAED,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAczD,CAAA"}

package/dist/types/current/text/VttCueStyle.js

@@ -0,0 +1,45 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { boolean, isOneOf, number, object } from '@amazon/vinyl-validation';
+/**
+ * Type guard for a DOM cue that is a `VTTCue` (and so carries the WebVTT layout
+ * properties). On platforms without `VTTCue`, cues are plain `TextTrackCue`s
+ * that cannot be styled.
+ */
+export function isVttCue(cue) {
+    return typeof VTTCue !== 'undefined' && cue instanceof VTTCue;
+}
+/**
+ * Applies the configured layout style to a `VTTCue`, setting only the
+ * properties present in `style`.
+ */
+export function applyVttCueStyle(cue, style) {
+    if (style.align !== undefined)
+        cue.align = style.align;
+    if (style.line !== undefined)
+        cue.line = style.line;
+    if (style.lineAlign !== undefined)
+        cue.lineAlign = style.lineAlign;
+    if (style.position !== undefined)
+        cue.position = style.position;
+    if (style.positionAlign !== undefined)
+        cue.positionAlign = style.positionAlign;
+    if (style.size !== undefined)
+        cue.size = style.size;
+    if (style.snapToLines !== undefined)
+        cue.snapToLines = style.snapToLines;
+    if (style.vertical !== undefined)
+        cue.vertical = style.vertical;
+}
+export const vttCueStyleValidator = object({
+    align: isOneOf('start', 'center', 'end', 'left', 'right').optional(),
+    line: number().or(isOneOf('auto')).optional(),
+    lineAlign: isOneOf('start', 'center', 'end').optional(),
+    position: number().or(isOneOf('auto')).optional(),
+    positionAlign: isOneOf('line-left', 'center', 'line-right', 'auto').optional(),
+    size: number().optional(),
+    snapToLines: boolean().optional(),
+    vertical: isOneOf('', 'rl', 'lr').optional(),
+});

package/dist/types/current/text/discoverDashTextTracks.d.ts

@@ -0,0 +1,24 @@
+import type { DashManifest } from '@amazon/vinyl-mpd-parser';
+import type { TextTrackInfo } from './TextTrack';
+/**
+ * Discovers sidecar text tracks from a DASH manifest.
+ *
+ * Considers an `<AdaptationSet>` to carry text when one of:
+ *  - `contentType="text"`
+ *  - its `mimeType`, or that of one of its `<Representation>`s, starts with
+ *    `text/` (e.g. `text/vtt`)
+ *
+ * Within a text adaptation set, each `<Representation>` becomes one
+ * {@link TextTrackInfo}. The `BaseURL` chain (MPD → Period → AdaptationSet →
+ * Representation) is resolved against the supplied `baseUrl`.
+ *
+ * Only sidecar (single-file) WebVTT renditions are surfaced. Segmented text
+ * tracks (`stpp`/`wvtt` codecs) are ignored - they would require streaming
+ * through MSE which the sidecar pipeline does not support.
+ *
+ * @param manifest The parsed DASH manifest.
+ * @param baseUrl The URL of the manifest, used as the root for `BaseURL`
+ * resolution.
+ */
+export declare function discoverDashTextTracks(manifest: DashManifest, baseUrl: string): readonly TextTrackInfo[];
+//# sourceMappingURL=discoverDashTextTracks.d.ts.map

package/dist/types/current/text/discoverDashTextTracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discoverDashTextTracks.d.ts","sourceRoot":"","sources":["../../../../src/text/discoverDashTextTracks.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CAClC,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,MAAM,GAChB,SAAS,aAAa,EAAE,CAwD1B"}

package/dist/types/current/text/discoverDashTextTracks.js

@@ -0,0 +1,110 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { resolveUrl } from '@amazon/vinyl-util';
+/**
+ * Discovers sidecar text tracks from a DASH manifest.
+ *
+ * Considers an `<AdaptationSet>` to carry text when one of:
+ *  - `contentType="text"`
+ *  - its `mimeType`, or that of one of its `<Representation>`s, starts with
+ *    `text/` (e.g. `text/vtt`)
+ *
+ * Within a text adaptation set, each `<Representation>` becomes one
+ * {@link TextTrackInfo}. The `BaseURL` chain (MPD → Period → AdaptationSet →
+ * Representation) is resolved against the supplied `baseUrl`.
+ *
+ * Only sidecar (single-file) WebVTT renditions are surfaced. Segmented text
+ * tracks (`stpp`/`wvtt` codecs) are ignored - they would require streaming
+ * through MSE which the sidecar pipeline does not support.
+ *
+ * @param manifest The parsed DASH manifest.
+ * @param baseUrl The URL of the manifest, used as the root for `BaseURL`
+ * resolution.
+ */
+export function discoverDashTextTracks(manifest, baseUrl) {
+    const out = [];
+    const periods = manifest.MPD.Period;
+    const mpdBase = chainBase(baseUrl, manifest.MPD.BaseURL);
+    for (let p = 0; p < periods.length; p++) {
+        const period = periods[p];
+        const periodBase = chainBase(mpdBase, period.BaseURL);
+        const adaptationSets = period.AdaptationSet ?? [];
+        for (const adaptationSet of adaptationSets) {
+            if (!isTextAdaptationSet(adaptationSet))
+                continue;
+            const asBase = chainBase(periodBase, adaptationSet.BaseURL);
+            const representations = adaptationSet.Representation ?? [];
+            for (const representation of representations) {
+                const repBase = chainBase(asBase, representation.BaseURL);
+                const uri = pickRepresentationUri(repBase, representation.id);
+                const mimeType = representation.mimeType ?? adaptationSet.mimeType ?? null;
+                // Only surface sidecar formats. Segmented text (stpp/wvtt) is
+                // intentionally skipped.
+                if (!isSidecarTextMime(mimeType))
+                    continue;
+                const language = adaptationSet.lang ?? null;
+                const roleValues = (adaptationSet.Role ?? [])
+                    .filter((d) => d.schemeIdUri === 'urn:mpeg:dash:role:2011')
+                    .map((d) => d.value)
+                    .filter((v) => v != null);
+                // Accessibility descriptors (e.g. SDH / hard-of-hearing) also
+                // describe the track's role; surface them as characteristics.
+                const accessibility = (adaptationSet.Accessibility ?? [])
+                    .map((d) => d.value)
+                    .filter((v) => v != null);
+                const characteristics = [...roleValues, ...accessibility];
+                const isCaption = roleValues.includes('caption');
+                const isDefault = roleValues.includes('main');
+                // DASH signals forced text via the `forced_subtitle` /
+                // `forced-subtitle` role value.
+                const forced = roleValues.includes('forced_subtitle') ||
+                    roleValues.includes('forced-subtitle');
+                out.push({
+                    id: `dash-text-${p}-${representation.id}`,
+                    kind: isCaption ? 'captions' : 'subtitles',
+                    language,
+                    label: language ?? representation.id,
+                    default: isDefault,
+                    forced,
+                    characteristics,
+                    uri,
+                    mimeType,
+                });
+            }
+        }
+    }
+    return out;
+}
+function isTextAdaptationSet(adaptationSet) {
+    if (adaptationSet.contentType === 'text')
+        return true;
+    const mt = adaptationSet.mimeType;
+    if (mt && mt.startsWith('text/'))
+        return true;
+    // `mimeType` may be declared on the Representation rather than the set.
+    return (adaptationSet.Representation ?? []).some((representation) => representation.mimeType?.startsWith('text/'));
+}
+function isSidecarTextMime(mimeType) {
+    // Permissive when manifest omits the MIME type, otherwise require a
+    // text/* MIME type. Segmented codec-only types like application/mp4
+    // (used with stpp/wvtt codecs) are excluded.
+    if (mimeType == null)
+        return true;
+    return mimeType.startsWith('text/');
+}
+function chainBase(parent, bases) {
+    if (!bases || bases.length === 0)
+        return parent;
+    return resolveUrl(bases[0]._content, parent);
+}
+function pickRepresentationUri(base, id) {
+    // For a sidecar text representation, the BaseURL is expected to point at
+    // the file. When the chain ends in a directory (trailing `/`), append a
+    // conventional `<id>.vtt` filename so the loader can fetch the resource.
+    if (base.endsWith('/')) {
+        return resolveUrl(`${id}.vtt`, base);
+    }
+    return base;
+}

package/dist/types/current/text/discoverHlsTextTracks.d.ts

@@ -0,0 +1,19 @@
+import type { HlsMainPlaylist } from '@amazon/vinyl-hls-parser';
+import type { TextTrackInfo } from './TextTrack';
+/**
+ * Discovers sidecar text tracks from an HLS multivariant playlist.
+ *
+ * Per RFC 8216 §4.3.4.2, subtitle renditions are signaled with
+ * `EXT-X-MEDIA:TYPE=SUBTITLES` and (when usable as sidecar) carry a `URI`
+ * attribute pointing at a media playlist or, in the simplified single-file
+ * case, a `.vtt` file directly.
+ *
+ * Closed captions (`TYPE=CLOSED-CAPTIONS`) are intentionally excluded - they
+ * are delivered in-band with the video stream and are surfaced by the browser
+ * automatically, not through a sidecar fetch.
+ *
+ * @param mainPlaylist The parsed HLS main playlist.
+ * @param baseUrl The URL of the main playlist, used to resolve relative URIs.
+ */
+export declare function discoverHlsTextTracks(mainPlaylist: HlsMainPlaylist, baseUrl: string): readonly TextTrackInfo[];
+//# sourceMappingURL=discoverHlsTextTracks.d.ts.map

package/dist/types/current/text/discoverHlsTextTracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discoverHlsTextTracks.d.ts","sourceRoot":"","sources":["../../../../src/text/discoverHlsTextTracks.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACjC,YAAY,EAAE,eAAe,EAC7B,OAAO,EAAE,MAAM,GAChB,SAAS,aAAa,EAAE,CA2B1B"}

package/dist/types/current/text/discoverHlsTextTracks.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { resolveUrl } from '@amazon/vinyl-util';
+/**
+ * Discovers sidecar text tracks from an HLS multivariant playlist.
+ *
+ * Per RFC 8216 §4.3.4.2, subtitle renditions are signaled with
+ * `EXT-X-MEDIA:TYPE=SUBTITLES` and (when usable as sidecar) carry a `URI`
+ * attribute pointing at a media playlist or, in the simplified single-file
+ * case, a `.vtt` file directly.
+ *
+ * Closed captions (`TYPE=CLOSED-CAPTIONS`) are intentionally excluded - they
+ * are delivered in-band with the video stream and are surfaced by the browser
+ * automatically, not through a sidecar fetch.
+ *
+ * @param mainPlaylist The parsed HLS main playlist.
+ * @param baseUrl The URL of the main playlist, used to resolve relative URIs.
+ */
+export function discoverHlsTextTracks(mainPlaylist, baseUrl) {
+    const out = [];
+    let index = 0;
+    const parentDefines = mainPlaylist.defines && Object.keys(mainPlaylist.defines).length > 0
+        ? mainPlaylist.defines
+        : undefined;
+    for (const rendition of mainPlaylist.alternativeRenditions) {
+        if (rendition.type !== 'SUBTITLES')
+            continue;
+        if (!rendition.uri)
+            continue;
+        const resolved = resolveUrl(rendition.uri, baseUrl);
+        out.push({
+            id: `hls-text-${index++}-${rendition.groupId}-${rendition.name}`,
+            kind: 'subtitles',
+            language: rendition.language ?? null,
+            label: rendition.name,
+            default: rendition.default === true,
+            forced: rendition.forced === true,
+            characteristics: rendition.characteristics ?? [],
+            uri: resolved,
+            // HLS subtitle renditions don't carry a MIME type; WebVTT is the
+            // overwhelmingly dominant format for sidecar HLS subtitles.
+            mimeType: 'text/vtt',
+            ...(parentDefines && { variables: parentDefines }),
+        });
+    }
+    return out;
+}

package/dist/types/current/text/mediaTextTrackProvider.d.ts

@@ -0,0 +1,34 @@
+import type { TextTrackKind } from './TextTrack';
+/**
+ * A handle to a DOM {@link TextTrack} created on the media element, plus a way
+ * to clear its cues.
+ */
+export interface TextTrackRef {
+    readonly track: TextTrack;
+    /**
+     * Removes all cues from the track. Must be called while the track is not
+     * `disabled` — `TextTrack.cues` reads null in the disabled state, so
+     * clearing a disabled track silently leaves its cues attached.
+     */
+    clear(): void;
+}
+/**
+ * Creates and hands out DOM text tracks for a media element, memoized per
+ * `(kind, label, language)`.
+ *
+ * `HTMLMediaElement.addTextTrack` tracks can never be removed, so creating a
+ * fresh one per activation would accumulate tracks — and any left in `showing`
+ * mode renders alongside the active one (captions "bleed through"). Reusing one
+ * track per key keeps exactly one track per distinct rendition.
+ */
+export interface MediaTextTrackProvider {
+    getOrCreate(kind: TextTrackKind, label?: string, language?: string): TextTrackRef;
+}
+export declare function createMediaTextTrackProvider(deps: {
+    /**
+     * The HTML media element on which to attach the in-band TextTrack
+     * representation.
+     */
+    readonly media: HTMLMediaElement;
+}): MediaTextTrackProvider;
+//# sourceMappingURL=mediaTextTrackProvider.d.ts.map

package/dist/types/current/text/mediaTextTrackProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaTextTrackProvider.d.ts","sourceRoot":"","sources":["../../../../src/text/mediaTextTrackProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;GAGG;AACH,MAAM,WAAW,YAAY;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IAEzB;;;;OAIG;IACH,KAAK,IAAI,IAAI,CAAA;CAChB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,sBAAsB;IACnC,WAAW,CACP,IAAI,EAAE,aAAa,EACnB,KAAK,CAAC,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,MAAM,GAClB,YAAY,CAAA;CAClB;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IAC/C;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAA;CACnC,GAAG,sBAAsB,CAwCzB"}

package/dist/types/current/text/mediaTextTrackProvider.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function createMediaTextTrackProvider(deps) {
+    const { media } = deps;
+    const cache = new Map();
+    const isAttached = (track) => {
+        for (let i = 0; i < media.textTracks.length; i++) {
+            if (media.textTracks[i] === track)
+                return true;
+        }
+        return false;
+    };
+    const create = (kind, label, language) => {
+        const track = media.addTextTrack(kind, label, language);
+        return {
+            track,
+            clear() {
+                if (!track.cues)
+                    return;
+                // Snapshot first — removeCue mutates the live list.
+                const all = Array.from(track.cues);
+                for (const cue of all)
+                    track.removeCue(cue);
+            },
+        };
+    };
+    return {
+        getOrCreate(kind, label, language) {
+            const key = `${kind}-${label}-${language}`;
+            const cached = cache.get(key);
+            // Resetting the media source (MSE `src = null; load()`) drops added
+            // tracks, so a cached track can become detached; recreate when so.
+            if (cached && isAttached(cached.track))
+                return cached;
+            const ref = create(kind, label, language);
+            cache.set(key, ref);
+            return ref;
+        },
+    };
+}

package/dist/types/current/text/parseWebVtt.d.ts

@@ -0,0 +1,60 @@
+import type { VttCueStyle } from './VttCueStyle';
+/**
+ * A single WebVTT cue.
+ *
+ * @see https://www.w3.org/TR/webvtt1/
+ */
+export interface WebVttCue {
+    /**
+     * Optional cue identifier, the line that appears before the timing line.
+     */
+    readonly id: string | null;
+    /**
+     * Cue start time in seconds.
+     */
+    readonly startTime: number;
+    /**
+     * Cue end time in seconds.
+     */
+    readonly endTime: number;
+    /**
+     * The cue text payload, with line breaks preserved as `\n`.
+     */
+    readonly text: string;
+    /**
+     * The authored cue settings from the timing line (position/line/size/
+     * align/vertical), when any were present. Preserved so a renderer can
+     * position the cue faithfully. Absent when the cue declared no settings.
+     */
+    readonly settings?: VttCueStyle;
+}
+/**
+ * The result of parsing a WebVTT document.
+ */
+export interface WebVttDocument {
+    /**
+     * Parsed cues in document order.
+     */
+    readonly cues: readonly WebVttCue[];
+    /**
+     * The raw CSS body of each `STYLE` block, in document order. These carry
+     * `::cue` rules (e.g. `::cue(.loud) { font-weight: bold }`) an HTML renderer
+     * can apply. Empty when the document declared no styles.
+     */
+    readonly styles: readonly string[];
+}
+/**
+ * Parses a WebVTT document into a list of cues.
+ *
+ * Implements a forgiving subset of the WebVTT 1.0 specification: header
+ * detection, comment blocks (lines starting with `NOTE`), styling/region
+ * blocks (STYLE bodies are captured, REGION skipped), cue identifiers, and
+ * HH:MM:SS.mmm or MM:SS.mmm timestamps with optional cue settings.
+ *
+ * @param input The raw WebVTT document text. Both LF and CRLF line endings
+ * are supported, and a leading BOM is stripped if present.
+ * @throws ValidationError if the input is missing the WEBVTT header.
+ * @see https://www.w3.org/TR/webvtt1/#webvtt-timestamp
+ */
+export declare function parseWebVtt(input: string): WebVttDocument;
+//# sourceMappingURL=parseWebVtt.d.ts.map

package/dist/types/current/text/parseWebVtt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseWebVtt.d.ts","sourceRoot":"","sources":["../../../../src/text/parseWebVtt.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEhD;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACtB;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAA;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,CAAA;IAEnC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAqGzD"}