@amazon/vinyl 1.2.0 → 2.0.4

package/dist/unit/types/current/streaming/createAllowedContentTypesValue.test.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAllowedContentTypesValue, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+describe('createAllowedContentTypesValue', () => {
+    let baseContentTypesValue;
+    let options;
+    beforeEach(() => {
+        baseContentTypesValue = data(Promise.resolve(new Set(['audio', 'video', 'text'])));
+        options = data({ allowedContentTypes: null });
+    });
+    it('passes all content types through when the allow list is null', async () => {
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['audio', 'video', 'text']));
+    });
+    it('keeps only the allowed media content types', async () => {
+        options.value = { allowedContentTypes: ['audio'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        // Text always passes through; video is dropped.
+        expect(result).toEqual(new Set(['audio', 'text']));
+    });
+    it('always keeps text even when only video is allowed', async () => {
+        options.value = { allowedContentTypes: ['video'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['video', 'text']));
+    });
+    it('keeps text even when the allow list is empty', async () => {
+        options.value = { allowedContentTypes: [] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['text']));
+    });
+    it('ignores allowed types not present in the manifest', async () => {
+        baseContentTypesValue.value = Promise.resolve(new Set(['audio']));
+        options.value = { allowedContentTypes: ['audio', 'video'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['audio']));
+    });
+    it('re-emits a newly filtered set when the allow list changes', async () => {
+        const value = createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        });
+        const emissions = [];
+        const unsub = value.onData((promise) => {
+            void promise.then((set) => emissions.push(set));
+        });
+        // Changing the allow list should produce a new, filtered emission,
+        // which is what drives the track to reload with only these types.
+        options.value = { allowedContentTypes: ['audio'] };
+        expect(await value.value).toEqual(new Set(['audio', 'text']));
+        unsub();
+        // Wait for all pending promise callbacks to resolve.
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(emissions).toEqual([
+            new Set(['audio', 'video', 'text']),
+            new Set(['audio', 'text']),
+        ]);
+    });
+});

package/dist/unit/types/current/streaming/createDefaultMediaTimelineTransformer.test.js

@@ -24,12 +24,16 @@ describe('createDefaultMediaTimelineTransformer', () => {
             persistentState: false,
         });
     });
-    function createDeps(timeline, preferredAudioLanguage = null) {
+    function createDeps(timeline, preferredAudioLanguage = null, codecOverrides = {}, preferDescriptiveAudio = false) {
         return {
             capabilities,
             drmController,
             mediaTimeline: data(Promise.resolve(timeline)),
-            options: data({ preferredAudioLanguage }),
+            options: data({
+                preferredAudioLanguage,
+                codecOverrides,
+                preferDescriptiveAudio,
+            }),
         };
     }
     it('passes through playable qualities', async () => {
@@ -48,12 +52,91 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.periods[0].qualities.length).toBe(1);
         expect(result.periods[0].qualities[0].metadata.qualityId).toBe('q1');
     });
+    it('selects main vs audio-description audio per preferDescriptiveAudio', async () => {
+        const makeTimeline = () => ({
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'main',
+                            lang: 'en',
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'dvs',
+                            lang: 'en',
+                            characteristics: [
+                                'public.accessibility.describes-video',
+                            ],
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        });
+        const audioIds = (t) => t.periods[0].qualities.map((q) => q.metadata.qualityId);
+        const byDefault = await createDefaultMediaTimelineTransformer(createDeps(makeTimeline())).value;
+        expect(audioIds(byDefault)).toEqual(['main']);
+        const optedIn = await createDefaultMediaTimelineTransformer(createDeps(makeTimeline(), null, {}, true)).value;
+        expect(audioIds(optedIn)).toEqual(['dvs']);
+    });
+    it('does not let a described rendition with a closer language tag evict the main audio', async () => {
+        // The main audio is region-tagged ('en-US') while the described
+        // rendition carries the generic 'en'. Against a preference of 'en',
+        // 'en' scores an exact match and 'en-US' only a related one, so if the
+        // language filter ran before the audio-description gate it would drop
+        // the main audio and strand the (not-opted-in) listener on described
+        // audio. The description gate must run first so the main audio wins.
+        const makeTimeline = () => ({
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'main',
+                            lang: 'en-US',
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'dvs',
+                            lang: 'en',
+                            characteristics: [
+                                'public.accessibility.describes-video',
+                            ],
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        });
+        const audioIds = (t) => t.periods[0].qualities.map((q) => q.metadata.qualityId);
+        const byDefault = await createDefaultMediaTimelineTransformer(createDeps(makeTimeline(), 'en')).value;
+        expect(audioIds(byDefault)).toEqual(['main']);
+        // Opting in still yields the described rendition (the eligibility gate
+        // keeps only it, then language selection picks among what remains).
+        const optedIn = await createDefaultMediaTimelineTransformer(createDeps(makeTimeline(), 'en', {}, true)).value;
+        expect(audioIds(optedIn)).toEqual(['dvs']);
+    });
     it('filters out unsupported mime types', async () => {
         capabilities.canPlayTypeMse.and.callFake((type) => type.includes('mp4a'));
         const timeline = {
@@ -76,12 +159,67 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.periods[0].qualities.length).toBe(1);
         expect(result.periods[0].qualities[0].metadata.qualityId).toBe('aac');
     });
+    it('denies a codec via codecOverrides even when the browser supports it', async () => {
+        capabilities.canPlayTypeMse.and.returnValue(true);
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'video',
+                            mimeType: 'video/mp4; codecs="hvc1.1"',
+                            qualityId: 'hevc',
+                        }),
+                        createQuality({
+                            contentType: 'video',
+                            mimeType: 'video/mp4; codecs="avc1.64001f"',
+                            qualityId: 'avc',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline, null, { hvc1: 'deny' })).value;
+        expect(result.periods[0].qualities.map((q) => q.metadata.qualityId)).toEqual(['avc']);
+    });
+    it('allows a codec via codecOverrides even when the browser reports it unsupported', async () => {
+        // Browser rejects everything; the override forces the codec through.
+        capabilities.canPlayTypeMse.and.returnValue(false);
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'video',
+                            mimeType: 'video/mp4; codecs="hvc1.1"',
+                            qualityId: 'hevc',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline, null, { hvc1: 'allow' })).value;
+        expect(result.periods[0].qualities.map((q) => q.metadata.qualityId)).toEqual(['hevc']);
+        // The override supersedes the browser check, which is not consulted.
+        expect(capabilities.canPlayTypeMse).not.toHaveBeenCalled();
+    });
     it('filters out unsupported key systems', async () => {
         drmController.isSupported.and.callFake((metadata) => Promise.resolve(metadata.contentProtections.length === 0
             ? { supported: true, persistentState: false }
@@ -109,6 +247,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
@@ -138,6 +277,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline, 'en')).value;
@@ -167,6 +307,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const options = data({
@@ -202,6 +343,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 5,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;

package/dist/unit/types/current/streaming/mediaTimelineAccessibilityFilter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mediaTimelineAccessibilityFilter.test.d.ts.map

package/dist/unit/types/current/streaming/mediaTimelineAccessibilityFilter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaTimelineAccessibilityFilter.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/streaming/mediaTimelineAccessibilityFilter.test.ts"],"names":[],"mappings":""}

package/dist/unit/types/current/streaming/mediaTimelineAccessibilityFilter.test.js

@@ -0,0 +1,99 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAudioDescriptionFilter, createEmptyMediaQualityMetadata, filterTimelineQualities, isAudioDescription, throwNoPlayableAudio, } from '@amazon/vinyl';
+function audioQuality(id, characteristics) {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            qualityId: id,
+            contentType: 'audio',
+            lang: 'en',
+            characteristics,
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function videoQuality() {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            qualityId: 'video',
+            contentType: 'video',
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function timelineOf(qualities) {
+    return {
+        periods: [{ startTime: 0, endTime: 10, qualities: [...qualities] }],
+        minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
+    };
+}
+/** The audio qualityIds kept after applying the filter. */
+function keptAudio(qualities, preferDescription) {
+    const filtered = filterTimelineQualities(createAudioDescriptionFilter(preferDescription), throwNoPlayableAudio, timelineOf(qualities));
+    return filtered.periods[0].qualities
+        .filter((q) => q.metadata.contentType === 'audio')
+        .map((q) => q.metadata.qualityId);
+}
+const DVS = 'public.accessibility.describes-video';
+describe('throwNoPlayableAudio', () => {
+    it('throws (defensive guard — the filter never strands audio)', () => {
+        expect(() => throwNoPlayableAudio()).toThrowError(/No playable audio rendition/);
+    });
+});
+describe('isAudioDescription', () => {
+    it('detects the HLS describes-video characteristic', () => {
+        expect(isAudioDescription({
+            ...createEmptyMediaQualityMetadata(),
+            characteristics: [DVS],
+        })).toBeTrue();
+    });
+    it('detects the DASH description role', () => {
+        expect(isAudioDescription({
+            ...createEmptyMediaQualityMetadata(),
+            characteristics: ['description'],
+        })).toBeTrue();
+    });
+    it('is false for a plain rendition', () => {
+        expect(isAudioDescription(createEmptyMediaQualityMetadata())).toBeFalse();
+    });
+});
+describe('createAudioDescriptionFilter', () => {
+    it('drops the description track when a main alternative exists (default)', () => {
+        const kept = keptAudio([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ], false);
+        expect(kept).toEqual(['main']);
+    });
+    it('keeps the description track when it is the only audio (never strands)', () => {
+        const kept = keptAudio([audioQuality('dvs', [DVS]), videoQuality()], false);
+        expect(kept).toEqual(['dvs']);
+    });
+    it('keeps only the description track when opted in', () => {
+        const kept = keptAudio([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ], true);
+        expect(kept).toEqual(['dvs']);
+    });
+    it('keeps all audio when opted in but no description exists', () => {
+        const kept = keptAudio([audioQuality('a', []), audioQuality('b', []), videoQuality()], true);
+        expect(kept).toEqual(['a', 'b']);
+    });
+    it('leaves non-audio qualities untouched', () => {
+        const filtered = filterTimelineQualities(createAudioDescriptionFilter(false), throwNoPlayableAudio, timelineOf([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ]));
+        expect(filtered.periods[0].qualities.some((q) => q.metadata.contentType === 'video')).toBeTrue();
+    });
+});

package/dist/unit/types/current/streaming/mediaTimelineFilter.test.js

@@ -27,8 +27,16 @@ describe('filterTimelineQualities', () => {
             },
         ],
         minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
         getDuration: () => Promise.resolve(Infinity),
     };
+    it('returns the timeline unchanged when the filter is null', () => {
+        // A null predicate (e.g. no language preference) is a no-op.
+        const result = filterTimelineQualities(null, () => {
+            throw new Error('empty');
+        }, timeline);
+        expect(result).toBe(timeline);
+    });
     it('filters qualities by predicate', () => {
         const result = filterTimelineQualities((q) => q.contentType === 'audio', () => {
             throw new Error('empty');
@@ -61,6 +69,7 @@ describe('filterTimelineQualitiesAsync', () => {
             },
         ],
         minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
         getDuration: () => Promise.resolve(Infinity),
     };
     it('filters qualities by async predicate', async () => {

package/dist/unit/types/current/streaming/mediaTimelineLanguageFilter.test.js

@@ -2,7 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createEmptyMediaQualityMetadata, createLanguageFilter, filterTimelineQualities, } from '@amazon/vinyl';
+import { createEmptyMediaQualityMetadata, createLanguageFilter, filterTimelineQualities, resolvePreferredLanguages, } from '@amazon/vinyl';
 import { throwLanguagesUnsupported } from '@amazon/vinyl';
 function createQuality(contentType, lang) {
     return {
@@ -14,15 +14,56 @@ function createQuality(contentType, lang) {
         getSegment: () => Promise.resolve(null),
     };
 }
+/** A single-period timeline of audio qualities (one per lang) plus a video. */
+function audioTimeline(langs) {
+    return {
+        periods: [
+            {
+                startTime: 0,
+                endTime: 10,
+                qualities: [
+                    ...langs.map((l) => createQuality('audio', l)),
+                    createQuality('video', null),
+                ],
+            },
+        ],
+        minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
+    };
+}
+/** The audio languages kept after filtering `timeline` with `preferred`. */
+function keptAudioLangs(timeline, preferred) {
+    return applyLanguageFilter(timeline, preferred, 'audio')
+        .periods[0].qualities.filter((q) => q.metadata.contentType === 'audio')
+        .map((q) => q.metadata.lang);
+}
 function applyLanguageFilter(timeline, preferredLanguage, contentType) {
     const filter = createLanguageFilter(preferredLanguage, contentType);
     if (!filter)
         return timeline;
     return filterTimelineQualities(filter, throwLanguagesUnsupported, timeline);
 }
+/** Temporarily overrides globalThis.navigator for the duration of `fn`. */
+function withNavigator(nav, fn) {
+    const original = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
+    Object.defineProperty(globalThis, 'navigator', {
+        value: nav,
+        configurable: true,
+    });
+    try {
+        fn();
+    }
+    finally {
+        if (original)
+            Object.defineProperty(globalThis, 'navigator', original);
+        else
+            delete globalThis.navigator;
+    }
+}
 describe('createLanguageFilter', () => {
-    it('returns null when preferredLanguage is null', () => {
-        expect(createLanguageFilter(null, 'audio')).toBeNull();
+    it('returns null for an empty preference list', () => {
+        expect(createLanguageFilter([], 'audio')).toBeNull();
     });
     it('returns a filter predicate when preferredLanguage is set', () => {
         expect(createLanguageFilter('en', 'audio')).toEqual(jasmine.any(Function));
@@ -41,6 +82,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
@@ -60,6 +102,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
@@ -75,6 +118,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 5,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
@@ -94,6 +138,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
@@ -109,6 +154,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         // 'xx' doesn't match 'ja', so all kept
@@ -136,6 +182,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         // 'en' matches period 1 but not period 2
@@ -167,6 +214,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
@@ -175,4 +223,45 @@ describe('createLanguageFilter', () => {
         // Period 2: no audio qualities have lang, all kept
         expect(result.periods[1].qualities.length).toBe(2);
     });
+    it('prefers the first matching language in an ordered list', () => {
+        const timeline = audioTimeline(['en', 'ja', 'fr']);
+        expect(keptAudioLangs(timeline, ['ja', 'en'])).toEqual(['ja']);
+        expect(keptAudioLangs(timeline, ['en', 'ja'])).toEqual(['en']);
+    });
+    it('falls through to a later preference when earlier ones are absent', () => {
+        const timeline = audioTimeline(['en', 'ja']);
+        expect(keptAudioLangs(timeline, ['ko', 'ja', 'en'])).toEqual(['ja']);
+    });
+    it('orders by navigator.languages when the preference is null', () => {
+        withNavigator({ languages: ['ja-JP', 'en-US'] }, () => {
+            const timeline = audioTimeline(['en', 'ja']);
+            expect(keptAudioLangs(timeline, null)).toEqual(['ja']);
+        });
+    });
+    it('returns null when null and navigator is unavailable', () => {
+        withNavigator(undefined, () => {
+            expect(createLanguageFilter(null, 'audio')).toBeNull();
+        });
+    });
+});
+describe('resolvePreferredLanguages', () => {
+    it('wraps a single string in a one-element list', () => {
+        expect(resolvePreferredLanguages('en')).toEqual(['en']);
+    });
+    it('returns an array preference as-is (already ordered)', () => {
+        expect(resolvePreferredLanguages(['ja', 'en'])).toEqual(['ja', 'en']);
+    });
+    it('falls back to navigator.languages when null', () => {
+        withNavigator({ languages: ['ja-JP', 'en-US'] }, () => {
+            expect(resolvePreferredLanguages(null)).toEqual(['ja-JP', 'en-US']);
+        });
+    });
+    it('returns an empty list when null and navigator is unavailable', () => {
+        withNavigator(undefined, () => {
+            expect(resolvePreferredLanguages(null)).toEqual([]);
+        });
+    });
+    it('returns an empty list for an empty array', () => {
+        expect(resolvePreferredLanguages([])).toEqual([]);
+    });
 });

package/dist/unit/types/current/text/SidecarTextTrackController.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SidecarTextTrackController.test.d.ts.map

package/dist/unit/types/current/text/SidecarTextTrackController.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SidecarTextTrackController.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/text/SidecarTextTrackController.test.ts"],"names":[],"mappings":""}