@amazon/vinyl 1.1.1 → 1.2.1

package/dist/unit/types/current/util/media/codecOverrides.test.d.ts

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

package/dist/unit/types/current/util/media/codecOverrides.test.d.ts.map

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

package/dist/unit/types/current/util/media/codecOverrides.test.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { resolveCodecOverride } from '@amazon/vinyl';
+describe('codecOverrides', () => {
+    describe('resolveCodecOverride', () => {
+        it('returns undefined when overrides are undefined', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="hvc1.1"', undefined)).toBeUndefined();
+        });
+        it('returns undefined when overrides are empty', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="hvc1.1"', {})).toBeUndefined();
+        });
+        it('returns undefined when no key matches', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="avc1.64001f"', {
+                hvc1: 'deny',
+            })).toBeUndefined();
+        });
+        it('matches a codec by prefix', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="hvc1.2.20000000.L123.B0"', { hvc1: 'deny' })).toBe('deny');
+        });
+        it('resolves an allow', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="av01.0.05M.08"', {
+                av01: 'allow',
+            })).toBe('allow');
+        });
+        it('is case-insensitive on the key', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="HVC1.1"', {
+                hvc1: 'deny',
+            })).toBe('deny');
+        });
+        it('deny wins over allow across multiple codecs', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="hvc1.1,mp4a.40.2"', {
+                mp4a: 'allow',
+                hvc1: 'deny',
+            })).toBe('deny');
+        });
+        it('returns undefined when the mimeType has no codecs', () => {
+            expect(resolveCodecOverride('video/mp4', { hvc1: 'deny' })).toBeUndefined();
+        });
+    });
+});

package/dist/unit/types/current/util/media/codecSupport.test.d.ts

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

package/dist/unit/types/current/util/media/codecSupport.test.d.ts.map

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

package/dist/unit/types/current/util/media/codecSupport.test.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { extractCodecs } from '@amazon/vinyl';
+describe('codecSupport', () => {
+    describe('extractCodecs', () => {
+        it('extracts a single codec from a mimeType', () => {
+            expect(extractCodecs('video/mp4; codecs="avc1.64001f"')).toEqual([
+                'avc1.64001f',
+            ]);
+        });
+        it('extracts multiple comma-separated codecs', () => {
+            expect(extractCodecs('video/mp4; codecs="avc1.64001f,mp4a.40.2"')).toEqual(['avc1.64001f', 'mp4a.40.2']);
+        });
+        it('handles unquoted codecs', () => {
+            expect(extractCodecs('audio/mp4; codecs=ac-3')).toEqual(['ac-3']);
+        });
+        it('returns empty when no codecs parameter is present', () => {
+            expect(extractCodecs('video/mp4')).toEqual([]);
+        });
+        it('trims whitespace around codecs', () => {
+            expect(extractCodecs('video/mp4; codecs="hvc1.1 , mp4a.40.2"')).toEqual(['hvc1.1', 'mp4a.40.2']);
+        });
+    });
+});

package/dist/unit/types/current/util/media/mimeType.test.d.ts

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

package/dist/unit/types/current/util/media/mimeType.test.d.ts.map

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

package/dist/unit/types/current/util/media/mimeType.test.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { mimeSubtype } from '@amazon/vinyl';
+describe('mimeSubtype', () => {
+    it('returns the subtype after the slash', () => {
+        expect(mimeSubtype('audio/mp4')).toBe('mp4');
+        expect(mimeSubtype('video/webm')).toBe('webm');
+    });
+    it('ignores codec and other parameters', () => {
+        expect(mimeSubtype('video/webm; codecs="vp9"')).toBe('webm');
+        expect(mimeSubtype('audio/mp4;codecs="mp4a.40.2"')).toBe('mp4');
+    });
+    it('lowercases and trims', () => {
+        expect(mimeSubtype('  VIDEO/MP4 ; codecs="avc1"')).toBe('mp4');
+    });
+    it('returns an empty string when there is no subtype', () => {
+        expect(mimeSubtype('video')).toBe('');
+        expect(mimeSubtype('')).toBe('');
+    });
+});

package/dist/unit/types/current/vinyl/VinylPlayer.test.js

@@ -594,6 +594,41 @@ describe('VinylPlayer', () => {
             expect(deps.playbackController.reset).toHaveBeenCalledOnceWith();
             expect(deps.trackController.reset).toHaveBeenCalledOnceWith();
         });
+        it('clears auto reset controller on reset', () => {
+            const error = new DrmError('test error');
+            player.dispatch('error', { target: player, error });
+            player.reset();
+            expect(deps.autoResetController.clear).toHaveBeenCalledOnceWith();
+        });
+        describe('resetPending', () => {
+            it('delegates to the auto reset controller', () => {
+                expect(player.resetPending).toBeFalse();
+                deps.autoResetController.resetPending = true;
+                expect(player.resetPending).toBeTrue();
+            });
+        });
+        describe('resetPendingChange event', () => {
+            it('re-dispatches resetPendingChange events from the auto reset controller', () => {
+                const spy = createEventSpy(player, 'resetPendingChange');
+                deps.autoResetController.dispatch('resetPendingChange', {
+                    previous: false,
+                    current: true,
+                });
+                expect(spy).toHaveBeenCalledOnceWith({
+                    previous: false,
+                    current: true,
+                });
+                spy.calls.reset();
+                deps.autoResetController.dispatch('resetPendingChange', {
+                    previous: true,
+                    current: false,
+                });
+                expect(spy).toHaveBeenCalledOnceWith({
+                    previous: true,
+                    current: false,
+                });
+            });
+        });
     });
     describe('when drmController emits error event', () => {
         it('re-dispatches the error event', () => {

package/dist/unit/types/current/vinyl/VinylPlayerAdBreaks.test.d.ts

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

package/dist/unit/types/current/vinyl/VinylPlayerAdBreaks.test.d.ts.map

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

package/dist/unit/types/current/vinyl/VinylPlayerAdBreaks.test.js

@@ -0,0 +1,142 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AdControllerImpl, createVinylPlayer, } from '@amazon/vinyl';
+import { externalDependencies } from '@amazon/vinyl-di';
+import { createMockVinylDependencies, MockTrack, } from '@amazon/vinyl/vinylTestUtil';
+import { MockHTMLAudioElement } from '@amazon/vinyl-util/browserTestUtil';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+describe('VinylPlayer ad break API', () => {
+    let adController;
+    let base;
+    let depFactories;
+    let player;
+    beforeEach(() => {
+        base = createMockVinylDependencies();
+        // Use a real ad controller so setTrackAds drives state and events that the
+        // player getters and redispatch reflect.
+        adController = new AdControllerImpl({
+            playbackController: base.playbackController,
+        });
+        depFactories = externalDependencies({ ...base, adController });
+        player = createVinylPlayer({ media: new MockHTMLAudioElement() }, depFactories);
+    });
+    afterEach(() => {
+        player.dispose();
+    });
+    function makeBreak(overrides = {}) {
+        return {
+            id: 'b1',
+            startTime: 10,
+            duration: 5,
+            placement: 'midroll',
+            restrict: {},
+            once: false,
+            resumeOffset: null,
+            playoutLimit: null,
+            resolutionTimeOffset: null,
+            skipControl: () => null,
+            ads: () => Promise.resolve([
+                {
+                    id: 'a1',
+                    startTime: 10,
+                    duration: 5,
+                    uri: 'ad.m3u8',
+                },
+            ]),
+            ...overrides,
+        };
+    }
+    function trackAds(...adBreaks) {
+        return { trackUri: 't1', adBreaks };
+    }
+    function simulateTimeUpdate(time) {
+        base.playbackController.currentTime = time;
+        base.playbackController.dispatch('timeUpdate', {
+            previous: 0,
+            current: time,
+        });
+    }
+    /** Waits for pending microtasks (ad resolution) to settle. */
+    async function flush() {
+        await Promise.resolve();
+        await Promise.resolve();
+    }
+    /**
+     * Activates a content parent track whose getAds() resolves the given ads
+     * and marks playback playing — the state the ad controller requires before
+     * it scans for midroll ingress. Awaits the async ad resolution.
+     */
+    async function setContent(ads) {
+        const track = new MockTrack();
+        track.uri = ads.trackUri;
+        track.active = true;
+        track.ads = ads;
+        base.playbackController.playing = true;
+        adController.setAdsProvider(track);
+        await flush();
+    }
+    it('returns empty defaults when no ad breaks are set', () => {
+        expect(player.currentTrackAds).toBeNull();
+        expect(player.currentAdBreak).toBeNull();
+    });
+    it('returns ad breaks from the player-level ad controller', async () => {
+        await setContent(trackAds(makeBreak()));
+        expect(player.currentTrackAds?.adBreaks.map((b) => b.id)).toEqual([
+            'b1',
+        ]);
+    });
+    it('redispatches currentTrackAdsChange from the ad controller', async () => {
+        const spy = createEventSpy(player, 'currentTrackAdsChange');
+        await setContent(trackAds(makeBreak()));
+        expect(spy).toHaveBeenCalled();
+    });
+    it('redispatches adBreakEntered and adBreakCompleted from the ad controller', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 10, duration: 5 })));
+        const entered = createEventSpy(player, 'adBreakEntered');
+        const completed = createEventSpy(player, 'adBreakCompleted');
+        simulateTimeUpdate(11);
+        await flush();
+        expect(entered).toHaveBeenCalledTimes(1);
+        expect(entered.calls.mostRecent().args[0].adBreak.id).toBe('b1');
+        // Exit via skipAd (updateTime is blocked while an ad is active)
+        player.skipAd();
+        expect(completed).toHaveBeenCalledTimes(1);
+        expect(completed.calls.mostRecent().args[0].adBreak.id).toBe('b1');
+    });
+    it('reflects the current ad break through the player getter', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 0, duration: 10 })));
+        simulateTimeUpdate(5);
+        await flush();
+        expect(player.currentAdBreak?.id).toBe('b1');
+    });
+    it('reflects the current ad through the player getter', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 0, duration: 10 })));
+        expect(player.currentAd).toBeNull();
+        simulateTimeUpdate(5);
+        await flush();
+        expect(player.currentAd?.id).toBe('a1');
+    });
+    it('skipAd delegates to the ad controller', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 0, duration: 10 })));
+        simulateTimeUpdate(5);
+        await flush();
+        expect(player.currentAdBreak).not.toBeNull();
+        player.skipAd();
+        expect(player.currentAdBreak).toBeNull();
+    });
+    it('skipAdBreak delegates to the ad controller', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 0, duration: 10 })));
+        simulateTimeUpdate(5);
+        await flush();
+        player.skipAdBreak();
+        expect(player.currentAdBreak).toBeNull();
+    });
+    it('skipAd is a no-op without an active break', () => {
+        expect(() => player.skipAd()).not.toThrow();
+    });
+    it('skipAdBreak is a no-op without an active break', () => {
+        expect(() => player.skipAdBreak()).not.toThrow();
+    });
+});

package/dist/unit/types/current/vinyl/VinylPlayerTextTracks.test.d.ts

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

package/dist/unit/types/current/vinyl/VinylPlayerTextTracks.test.d.ts.map

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

package/dist/unit/types/current/vinyl/VinylPlayerTextTracks.test.js

@@ -0,0 +1,188 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createVinylPlayer, } from '@amazon/vinyl';
+import { externalDependencies } from '@amazon/vinyl-di';
+import { createMockVinylDependencies, MockTextTrackController, MockTrack, } from '@amazon/vinyl/vinylTestUtil';
+import { MockHTMLAudioElement } from '@amazon/vinyl-util/browserTestUtil';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+/**
+ * These tests cover the player's read-through getters and event redispatch
+ * across track changes. Selection itself is declarative (driven by
+ * `VinylOptions.text`), so the tests drive a {@link MockTextTrackController}'s
+ * state and events directly rather than calling any imperative select API.
+ */
+describe('VinylPlayer text track API', () => {
+    let deps;
+    let depFactories;
+    let player;
+    beforeEach(() => {
+        deps = createMockVinylDependencies();
+        depFactories = externalDependencies(deps);
+        player = createVinylPlayer({ media: new MockHTMLAudioElement() }, depFactories);
+    });
+    afterEach(() => {
+        player.dispose();
+    });
+    function info(overrides = {}) {
+        return {
+            id: 't1',
+            kind: 'subtitles',
+            language: 'en',
+            label: 'A',
+            default: false,
+            forced: false,
+            characteristics: [],
+            uri: 'a.vtt',
+            mimeType: 'text/vtt',
+            ...overrides,
+        };
+    }
+    function makeTrackWithController() {
+        const track = new MockTrack();
+        const controller = new MockTextTrackController();
+        track.textTrackController = controller;
+        return { track, controller };
+    }
+    /** Sets the controller's track list and emits the change (as the real one does). */
+    function setTracks(controller, tracks) {
+        const previous = controller.textTracks;
+        controller.textTracks = tracks;
+        controller.dispatch('textTracksChange', { previous, current: tracks });
+    }
+    /** Sets the controller's active selection and emits the change. */
+    function setActive(controller, current) {
+        const previous = controller.activeTextTrack;
+        controller.activeTextTrack = current;
+        controller.dispatch('activeTextTrackChange', { previous, current });
+    }
+    function activate(track) {
+        deps.trackController.activeTrack = track;
+        deps.trackController.dispatch('trackActivated', { track });
+    }
+    it('returns empty defaults when no current track', () => {
+        expect(player.textTracks).toEqual([]);
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('returns text tracks from the current track', () => {
+        const { track, controller } = makeTrackWithController();
+        controller.textTracks = [info()];
+        activate(track);
+        expect(player.textTracks.length).toBe(1);
+    });
+    it('reflects the current track controller active selection', () => {
+        const { track, controller } = makeTrackWithController();
+        controller.textTracks = [info()];
+        activate(track);
+        setActive(controller, info());
+        expect(player.activeTextTrack?.id).toBe('t1');
+        setActive(controller, null);
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('reports null active when the current track has no controller', () => {
+        const track = new MockTrack();
+        activate(track);
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('redispatches textTracksChange events from the active controller', () => {
+        const { track, controller } = makeTrackWithController();
+        activate(track);
+        const spy = createEventSpy(player, 'textTracksChange');
+        setTracks(controller, [info({ language: null })]);
+        expect(spy).toHaveBeenCalled();
+    });
+    it('fires textTracksChange when switching to a track with a different list', () => {
+        const a = makeTrackWithController();
+        const b = makeTrackWithController();
+        setTracks(a.controller, [info({ id: 't1', language: 'en' })]);
+        setTracks(b.controller, [
+            info({ id: 't2', language: 'fr', label: 'B' }),
+        ]);
+        activate(a.track);
+        const spy = createEventSpy(player, 'textTracksChange');
+        activate(b.track);
+        expect(spy).toHaveBeenCalled();
+    });
+    it('fires activeTextTrackChange when switching tracks', () => {
+        const a = makeTrackWithController();
+        const b = makeTrackWithController();
+        setTracks(a.controller, [info({ id: 't1' })]);
+        setActive(a.controller, info({ id: 't1' }));
+        activate(a.track);
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        activate(b.track);
+        expect(spy).toHaveBeenCalled();
+    });
+    it('re-announces the content caption after an ad break so it does not read as off', () => {
+        // Regression: enabling captions during an ad and then letting content
+        // resume left consumers that track state via activeTextTrackChange
+        // believing captions were off, because the outgoing ad controller emits
+        // a clearing activeTextTrackChange(null) while the content's preserved
+        // (here forced) selection is restored silently on activate().
+        const content = makeTrackWithController();
+        const contentForced = info({
+            id: 'c-forced',
+            label: 'English (Forced)',
+            default: true,
+            forced: true,
+            uri: 'c.vtt',
+        });
+        setTracks(content.controller, [contentForced]);
+        setActive(content.controller, contentForced);
+        const ad = makeTrackWithController();
+        const adCc = info({ id: 'ad-cc', label: 'English', uri: 'ad.vtt' });
+        setTracks(ad.controller, [adCc]);
+        // Content becomes current.
+        activate(content.track);
+        // Enter the ad break: the content selection is preserved (deactivate
+        // keeps the selection) rather than cleared.
+        deps.adController.currentAdBreak = { placement: 'midroll' };
+        content.controller.deactivate();
+        activate(ad.track);
+        // Viewer enables the ad's captions during the break.
+        setActive(ad.controller, adCc);
+        expect(player.activeTextTrack?.id).toBe('ad-cc');
+        // Ad ends, content resumes.
+        deps.adController.currentAdBreak = null;
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        content.controller.activate();
+        activate(content.track);
+        // The player reports the content's forced caption as active again and,
+        // crucially, the last active-change event announces it — not the ad's
+        // clearing null.
+        expect(player.activeTextTrack?.id).toBe('c-forced');
+        expect(spy).toHaveBeenCalled();
+        const lastCurrent = spy.calls.mostRecent().args[0].current;
+        expect(lastCurrent?.id).toBe('c-forced');
+    });
+    it('announces empty tracks and null active when the track is torn down', () => {
+        // Real teardown (unload) transitions to null: the player must emit the
+        // cleared list/selection so consumers see captions go away.
+        const a = makeTrackWithController();
+        const t = info({ id: 't1' });
+        setTracks(a.controller, [t]);
+        setActive(a.controller, t);
+        activate(a.track);
+        const tracksSpy = createEventSpy(player, 'textTracksChange');
+        const activeSpy = createEventSpy(player, 'activeTextTrackChange');
+        // trackDeactivated with no ad break tears the current track down to null.
+        deps.trackController.activeTrack = null;
+        deps.trackController.dispatch('trackDeactivated', { track: a.track });
+        expect(tracksSpy).toHaveBeenCalled();
+        expect(tracksSpy.calls.mostRecent().args[0].current).toEqual([]);
+        expect(activeSpy).toHaveBeenCalled();
+        expect(activeSpy.calls.mostRecent().args[0].current).toBeNull();
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('does not emit activeTextTrackChange when neither track has an active selection', () => {
+        // Both tracks are text-capable but nothing is active — the current
+        // track change should not manufacture a spurious active-change event.
+        const a = makeTrackWithController();
+        const b = makeTrackWithController();
+        activate(a.track);
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        activate(b.track);
+        expect(spy).not.toHaveBeenCalled();
+    });
+});

package/dist/vinylTestUtil/index.js

@@ -219,8 +219,8 @@ var defaultFrequencyAnalyzerOptions = {
 };
 var FrequencyAnalyzer = class {
   constructor(audioContext, source, options) {
-    this.audioContext = audioContext;
-    this.source = source;
+    __publicField(this, "audioContext", audioContext);
+    __publicField(this, "source", source);
     __publicField(this, "data");
     __publicField(this, "analyser");
     __publicField(this, "options");
@@ -347,7 +347,6 @@ var affordanceBefore = 1;
 var affordanceAfter = 3;
 async function expectTrackPlaysUntil(player, endTime, timeout = 10) {
   await onPlaying(player);
-  await onCanPlayThrough(player);
   await onTimeUpdate(player);
   expect(player.currentTime).withContext("currentTime must be less than endTime").toBeLessThan(endTime);
   await assertFrequency();
@@ -392,7 +391,7 @@ async function expectTrackPlays(player) {
 async function expectPlaylistPlays(player, playlist) {
   var _a2;
   const { dispose, add } = createDisposer();
-  const trackTimeout = PLAYBACK_DURATION + 30;
+  const trackTimeout = PLAYBACK_DURATION + 60;
   const queueEnded = add(createEventSpy(player, "queueEnded"));
   const queueChange = add(createEventSpy(player, "queueChange"));
   const trackChange = add(createEventSpy(player, "currentTrackChange"));
@@ -472,8 +471,8 @@ import {
 import { setTestTimeout } from "@amazon/vinyl-util/browserTestUtil";
 var VinylSuite = class {
   constructor(playerFactory, options) {
-    this.playerFactory = playerFactory;
-    this.options = options;
+    __publicField(this, "playerFactory", playerFactory);
+    __publicField(this, "options", options);
     __publicField(this, "logPrefix", createLogPrefix2(this));
     __publicField(this, "_player", null);
     __publicField(this, "visibilityChangeHandler", () => {
@@ -623,6 +622,7 @@ var MockAutoResetController = class extends MockEventHost3 {
     super(...arguments);
     __publicField(this, "setError", spyFactory3("setError"));
     __publicField(this, "clear", spyFactory3("clear"));
+    __publicField(this, "resetPending", false);
   }
 };
 
@@ -739,7 +739,6 @@ var spyFactory5 = createSpyFactory6();
 var MockMediaSourceController = class extends MockEventHost4 {
   constructor() {
     super(...arguments);
-    __publicField(this, "duration", 0);
     __publicField(this, "readyState", "closed");
     __publicField(this, "createSourceBuffer", spyFactory5("createSourceBuffer"));
     __publicField(this, "endOfStream", spyFactory5("endOfStream"));
@@ -846,7 +845,11 @@ var MockDrmController = class extends MockEventHost7 {
 import { createSpyFactory as createSpyFactory11 } from "@amazon/vinyl-util/browserTestUtil";
 import { data as data2 } from "@amazon/vinyl-observable";
 var createSpy = jasmine.createSpy;
-var emptyTimeline = { periods: [], minBufferTime: 0 };
+var emptyTimeline = {
+  periods: [],
+  minBufferTime: 0,
+  getDuration: () => Promise.resolve(Infinity)
+};
 var spyFactory10 = createSpyFactory11();
 function createMockHlsDependencies() {
   const playbackController = new MockPlaybackController();
@@ -938,7 +941,11 @@ var MockDashManifestController = class {
 import { createSpyFactory as createSpyFactory13 } from "@amazon/vinyl-util/browserTestUtil";
 import { data as data4 } from "@amazon/vinyl-observable";
 var createSpy2 = jasmine.createSpy;
-var emptyTimeline2 = { periods: [], minBufferTime: 0 };
+var emptyTimeline2 = {
+  periods: [],
+  minBufferTime: 0,
+  getDuration: () => Promise.resolve(Infinity)
+};
 var spyFactory12 = createSpyFactory13();
 function createMockDashDependencies() {
   const playbackController = new MockPlaybackController();
@@ -976,7 +983,6 @@ var MockSegmentController = class extends MockEventHost8 {
   constructor() {
     super(...arguments);
     __publicField(this, "error", null);
-    __publicField(this, "getDuration", spyFactory13("getDuration"));
     __publicField(this, "configure", spyFactory13("configure"));
     __publicField(this, "fetchedRanges", emptyRanges);
     __publicField(this, "activate", spyFactory13("activate"));
@@ -1124,7 +1130,7 @@ import { createSpyFactory as createSpyFactory22 } from "@amazon/vinyl-util/brows
 var spyFactory21 = createSpyFactory22();
 var MockCommonMediaKeySystemAccess = class {
   constructor(keySystem) {
-    this.keySystem = keySystem;
+    __publicField(this, "keySystem", keySystem);
     __publicField(this, "createMediaKeys", spyFactory21("createMediaKeys"));
   }
 };
@@ -1172,7 +1178,7 @@ import { createSpyFactory as createSpyFactory25 } from "@amazon/vinyl-util/brows
 var spyFactory24 = createSpyFactory25();
 var MockWebKitMediaKeys = class {
   constructor(keySystem) {
-    this.keySystem = keySystem;
+    __publicField(this, "keySystem", keySystem);
     __publicField(this, "createSession", spyFactory24("createSession"));
   }
 };
@@ -1233,7 +1239,7 @@ import { createSpyFactory as createSpyFactory27 } from "@amazon/vinyl-util/brows
 var spyFactory26 = createSpyFactory27();
 var MockMSMediaKeys = class {
   constructor(keySystem) {
-    this.keySystem = keySystem;
+    __publicField(this, "keySystem", keySystem);
     __publicField(this, "createSession", spyFactory26("createSession"));
   }
 };
@@ -1306,7 +1312,7 @@ import {
 var mimeCodec = 'audio/mp4;codecs="mp4a.40.5"';
 var ControlledMediaSource = class {
   constructor(sourceAsset = vinylTestAssets.segmentedStreaming.aac_60s_2ch_16bit_44100Hz_48kbps) {
-    this.sourceAsset = sourceAsset;
+    __publicField(this, "sourceAsset", sourceAsset);
     __publicField(this, "length");
     __publicField(this, "_currentIndex", 0);
     __publicField(this, "mediaSource", createMediaSource());