@amazon/vinyl 1.1.1 → 2.0.0

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/mediaSource.test.js

@@ -57,6 +57,12 @@ describe('mediaSource', () => {
             expect(isTypeSupported('type2')).toBeTrue();
             expect(MockMediaSourceGlobal.isTypeSupported).toHaveBeenCalledOnceWith('type2');
         });
+        it('delegates to the native MediaSource.isTypeSupported', () => {
+            global.MediaSource = MockMediaSourceGlobal;
+            MockMediaSourceGlobal.isTypeSupported.and.returnValue(true);
+            expect(isTypeSupported('video/mp4; codecs="hvc1.2.20000000.L123.B0"')).toBeTrue();
+            expect(MockMediaSourceGlobal.isTypeSupported).toHaveBeenCalled();
+        });
     });
     describe('onMediaSourceOpen', () => {
         let mediaSource;

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

@@ -148,42 +148,154 @@ describe('VinylPlayer', () => {
         pC.dispatch('play', event);
         expect(spy).toHaveBeenCalledOnceWith(event);
     });
-    it('re-dispatches currentTrackChange from the track controller', () => {
-        const spy = createSpy('currentTrackChange');
-        player.on('currentTrackChange', spy);
+    it('re-dispatches trackActivated and trackDeactivated from the track controller', () => {
+        const activatedSpy = createSpy('trackActivated');
+        const deactivatedSpy = createSpy('trackDeactivated');
+        player.on('trackActivated', activatedSpy);
+        player.on('trackDeactivated', deactivatedSpy);
         const trackController = deps.trackController;
-        const mockTrackA = new MockTrack();
-        const mockTrackB = new MockTrack();
-        trackController.dispatch('currentTrackChange', {
-            previous: mockTrackA,
-            current: mockTrackB,
+        const mockTrack = new MockTrack();
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        expect(activatedSpy).toHaveBeenCalledOnceWith({ track: mockTrack });
+        trackController.dispatch('trackDeactivated', { track: mockTrack });
+        expect(deactivatedSpy).toHaveBeenCalledOnceWith({ track: mockTrack });
+    });
+    it('ignores a repeat trackActivated for the already-active track', () => {
+        const trackController = deps.trackController;
+        const mockTrack = new MockTrack();
+        const seekRangeSpy = createSpy('seekRangeChange');
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        player.on('seekRangeChange', seekRangeSpy);
+        // Re-activating the same track is a no-op transition (no re-wiring or
+        // state-change events).
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        expect(seekRangeSpy).not.toHaveBeenCalled();
+    });
+    describe('load span metrics', () => {
+        it('republishes the current track loadSpanMeasured as an attributed loadSpan', () => {
+            const spy = createSpy('loadSpan');
+            player.on('loadSpan', spy);
+            const mockTrack = new MockTrack();
+            mockTrack.uri = 'track-a';
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrack,
+            });
+            mockTrack.dispatch('loadSpanMeasured', {
+                kind: 'initSegment',
+                startTime: 1,
+                endTime: 2,
+            });
+            expect(spy).toHaveBeenCalledOnceWith({
+                kind: 'initSegment',
+                startTime: 1,
+                endTime: 2,
+                trackUri: 'track-a',
+            });
+        });
+        it('attributes a DRM license span to the track carried on the measurement', () => {
+            const spy = createSpy('loadSpan');
+            player.on('loadSpan', spy);
+            // The license span is stamped at the source with the initiating
+            // track. Even when a different track is current, the span must
+            // attribute to the track the measurement carries.
+            const currentTrack = new MockTrack();
+            currentTrack.uri = 'track-current';
+            deps.trackController.activeTrack = currentTrack;
+            deps.drmController.dispatch('loadSpanMeasured', {
+                kind: 'license',
+                startTime: 3,
+                endTime: 5,
+                trackUri: 'track-preloaded',
+            });
+            expect(spy).toHaveBeenCalledOnceWith({
+                kind: 'license',
+                startTime: 3,
+                endTime: 5,
+                trackUri: 'track-preloaded',
+            });
         });
-        expect(spy).toHaveBeenCalledOnceWith({
-            previous: mockTrackA,
-            current: mockTrackB,
+        it('does not emit a license span the DRM controller could not attribute', () => {
+            const spy = createSpy('loadSpan');
+            player.on('loadSpan', spy);
+            const currentTrack = new MockTrack();
+            currentTrack.uri = 'track-current';
+            deps.trackController.activeTrack = currentTrack;
+            // A measurement with no trackUri (the initiating track was unknown)
+            // is dropped rather than misattributed to the current track.
+            deps.drmController.dispatch('loadSpanMeasured', {
+                kind: 'license',
+                startTime: 3,
+                endTime: 5,
+            });
+            expect(spy).not.toHaveBeenCalled();
         });
-        spy.calls.reset();
-        trackController.dispatch('currentTrackChange', {
-            previous: mockTrackB,
-            current: null,
+        it('stops republishing after the track is no longer current', () => {
+            const spy = createSpy('loadSpan');
+            player.on('loadSpan', spy);
+            const mockTrack = new MockTrack();
+            mockTrack.uri = 'track-a';
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrack,
+            });
+            deps.trackController.dispatch('trackDeactivated', {
+                track: mockTrack,
+            });
+            mockTrack.dispatch('loadSpanMeasured', {
+                kind: 'manifest',
+                startTime: 1,
+                endTime: 2,
+            });
+            expect(spy).not.toHaveBeenCalled();
         });
-        expect(spy).toHaveBeenCalledOnceWith({
-            previous: mockTrackB,
-            current: null,
+    });
+    it('reloads the current track on a codecUnsupported event', () => {
+        const trackController = deps.trackController;
+        const mockTrack = new MockTrack();
+        // Make the track the current one so its streaming events are
+        // redispatched onto the player.
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        mockTrack.dispatch('codecUnsupported', {
+            mimeType: 'video/mp4; codecs="hvc1.1"',
+            contentType: 'video',
+        });
+        expect(trackController.reset).toHaveBeenCalledOnceWith(true);
+    });
+    it('does not reload the current track on codecUnsupported while an ad is playing', () => {
+        const trackController = deps.trackController;
+        // An ad break currently contains the playhead.
+        deps.adController.currentAdBreak = {
+            id: 'b1',
+            startTime: 0,
+            duration: 10,
+            placement: 'preroll',
+            ads: () => Promise.resolve([]),
+            restrict: {},
+            once: false,
+            resumeOffset: null,
+            playoutLimit: null,
+            resolutionTimeOffset: null,
+            skipControl: () => null,
+        };
+        const mockTrack = new MockTrack();
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        mockTrack.dispatch('codecUnsupported', {
+            mimeType: 'video/mp4; codecs="hvc1.1"',
+            contentType: 'video',
         });
+        expect(trackController.reset).not.toHaveBeenCalled();
     });
     describe('currentTrack', () => {
         it('returns the currently active track', () => {
-            expect(player.currentTrack).toBeNull();
+            expect(player.activeTrack).toBeNull();
             const mockTrackA = new MockTrack();
             mockTrackA.uri = 'srcA';
             const mockTrackB = new MockTrack();
             mockTrackB.uri = 'srcB';
-            expect(player.currentTrack).toBeNull();
-            deps.trackController.currentTrack = mockTrackA;
-            expect(player.currentTrack).toBe(mockTrackA);
-            deps.trackController.currentTrack = mockTrackB;
-            expect(player.currentTrack).toBe(mockTrackB);
+            expect(player.activeTrack).toBeNull();
+            deps.trackController.activeTrack = mockTrackA;
+            expect(player.activeTrack).toBe(mockTrackA);
+            deps.trackController.activeTrack = mockTrackB;
+            expect(player.activeTrack).toBe(mockTrackB);
         });
     });
     describe('fetchedRanges', () => {
@@ -192,7 +304,7 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const expectedRanges = new RangesImpl([[0, 10]]);
             mockTrackA.fetchedRanges = expectedRanges;
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.fetchedRanges).toEqual(expectedRanges);
         });
     });
@@ -204,7 +316,7 @@ describe('VinylPlayer', () => {
                 [0, 10],
                 [30, 60],
             ]);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.fetchedTime).toEqual(10);
             deps.playbackController.currentTime = 6;
             expect(player.fetchedTime).toEqual(10);
@@ -219,7 +331,7 @@ describe('VinylPlayer', () => {
             expect(player.fetchedTimePercent).toBe(0);
             const mockTrackA = new MockTrack();
             mockTrackA.fetchedRanges = new RangesImpl([[0, 50]]);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             deps.playbackController.duration = 100;
             expect(player.fetchedTimePercent).toEqual(0.5);
             deps.playbackController.duration = Number.NaN;
@@ -233,18 +345,16 @@ describe('VinylPlayer', () => {
             const event = {};
             mockTrackA.dispatch('fetchedRangesChange', event);
             expect(fetchedRangesChangeSpy).not.toHaveBeenCalled();
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrackA,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrackA,
             });
             expect(fetchedRangesChangeSpy).toHaveBeenCalledOnceWith(event); // Emitted on track change
             fetchedRangesChangeSpy.calls.reset();
             mockTrackA.dispatch('fetchedRangesChange', event);
             expect(fetchedRangesChangeSpy).toHaveBeenCalledOnceWith(event);
             fetchedRangesChangeSpy.calls.reset();
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: mockTrackA,
-                current: null,
+            deps.trackController.dispatch('trackDeactivated', {
+                track: mockTrackA,
             });
             expect(fetchedRangesChangeSpy).toHaveBeenCalledOnceWith(event); // Emitted on track change
             fetchedRangesChangeSpy.calls.reset();
@@ -274,7 +384,7 @@ describe('VinylPlayer', () => {
             mockTrackA.getStreamingQuality.and.returnValue(streamingQuality);
             mockTrackA.getBufferingQuality.and.returnValue(bufferingQuality);
             mockTrackA.getPlaybackQuality.and.returnValue(playbackQuality);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.getStreamingQuality('audio')).toEqual(streamingQuality);
             expect(player.getBufferingQuality('audio')).toEqual(bufferingQuality);
             expect(player.getPlaybackQuality('audio')).toEqual(playbackQuality);
@@ -283,7 +393,7 @@ describe('VinylPlayer', () => {
             expect(player.contentTypes).toEqual(new Set());
             const mockTrackA = new MockTrack();
             mockTrackA.contentTypes = new Set(['audio', 'video']);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.contentTypes).toEqual(new Set(['audio', 'video']));
         });
         it('returns qualities from current track', () => {
@@ -291,7 +401,7 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const q = [createEmptyMediaQualityMetadata()];
             mockTrackA.qualities = q;
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.qualities).toBe(q);
         });
         it('returns qualitiesUnfiltered from current track', () => {
@@ -299,7 +409,7 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const q = [createEmptyMediaQualityMetadata()];
             mockTrackA.qualitiesUnfiltered = q;
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.qualitiesUnfiltered).toBe(q);
         });
         it('deprecated getters work for backward compatibility', () => {
@@ -312,7 +422,7 @@ describe('VinylPlayer', () => {
             mockTrackA.getStreamingQuality.and.callFake((contentType) => contentType === 'audio' ? audioQuality : null);
             mockTrackA.getBufferingQuality.and.callFake((contentType) => contentType === 'audio' ? audioQuality : null);
             mockTrackA.getPlaybackQuality.and.callFake((contentType) => contentType === 'audio' ? audioQuality : null);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             // Test deprecated getters
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             expect(player.streamingQuality).toEqual(audioQuality);
@@ -338,9 +448,8 @@ describe('VinylPlayer', () => {
                 };
                 const mockTrackA = new MockTrack();
                 mockTrackA.getPlaybackQuality.and.callFake((contentType) => contentType === 'audio' ? qualityA : null);
-                deps.trackController.dispatch('currentTrackChange', {
-                    previous: null,
-                    current: mockTrackA,
+                deps.trackController.dispatch('trackActivated', {
+                    track: mockTrackA,
                 });
                 expect(playbackQualityChangeSpy).toHaveBeenCalledOnceWith({
                     previous: null,
@@ -357,9 +466,8 @@ describe('VinylPlayer', () => {
                     current: qualityB,
                 });
                 playbackQualityChangeSpy.calls.reset();
-                deps.trackController.dispatch('currentTrackChange', {
-                    previous: mockTrackA,
-                    current: null,
+                deps.trackController.dispatch('trackDeactivated', {
+                    track: mockTrackA,
                 });
                 expect(playbackQualityChangeSpy).toHaveBeenCalledOnceWith({
                     previous: qualityB,
@@ -372,9 +480,8 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const q = [createEmptyMediaQualityMetadata()];
             mockTrackA.qualities = q;
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrackA,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrackA,
             });
             expect(spy).toHaveBeenCalledOnceWith({
                 previous: [],
@@ -386,9 +493,8 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const q = [createEmptyMediaQualityMetadata()];
             mockTrackA.qualitiesUnfiltered = q;
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrackA,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrackA,
             });
             expect(spy).toHaveBeenCalledOnceWith({
                 previous: [],
@@ -449,23 +555,6 @@ describe('VinylPlayer', () => {
             expect(configSpy).not.toHaveBeenCalled();
         });
     });
-    describe('when preferredAudioLanguage changes', () => {
-        it('clears prefetch', () => {
-            expect(deps.trackController.clearPrefetch).not.toHaveBeenCalled();
-            player.configure({ preferredAudioLanguage: 'ja' });
-            expect(deps.trackController.clearPrefetch).toHaveBeenCalledWith();
-        });
-        it('does not clear prefetch when value is unchanged', () => {
-            player.configure({ preferredAudioLanguage: 'ja' });
-            deps.trackController.clearPrefetch.calls.reset();
-            player.configure({ preferredAudioLanguage: 'ja' });
-            expect(deps.trackController.clearPrefetch).not.toHaveBeenCalled();
-        });
-        it('does not clear prefetch on initial options', () => {
-            // clearPrefetch should not have been called from the initial options set
-            expect(deps.trackController.clearPrefetch).not.toHaveBeenCalled();
-        });
-    });
     describe('client', () => {
         it('returns an object with the injected capabilities and user agent info', () => {
             expect(player.client).toEqual({
@@ -512,7 +601,7 @@ describe('VinylPlayer', () => {
             player.reset();
             expect(deps.drmController.reset).toHaveBeenCalledOnceWith();
             expect(deps.playbackController.reset).toHaveBeenCalledOnceWith();
-            expect(deps.trackController.reset).toHaveBeenCalledOnceWith();
+            expect(deps.trackController.reset).toHaveBeenCalledOnceWith(false);
         });
         it('clears the error state', () => {
             const error = new DrmError('test error');
@@ -549,9 +638,8 @@ describe('VinylPlayer', () => {
             const resetSpy = createEventSpy(player, 'reset');
             const mockTrack = new MockTrack();
             // Set current track
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrack,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrack,
             });
             // Simulate track emitting reset event
             mockTrack.dispatch('reset', {});
@@ -561,9 +649,8 @@ describe('VinylPlayer', () => {
             const resetSpy = createEventSpy(player, 'reset');
             const mockTrack = new MockTrack();
             // Set current track
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrack,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrack,
             });
             // Track reset events should not bubble
             mockTrack.dispatch('reset', {});
@@ -592,7 +679,42 @@ describe('VinylPlayer', () => {
             expect(player.error).toBeNull();
             expect(deps.drmController.reset).toHaveBeenCalledOnceWith();
             expect(deps.playbackController.reset).toHaveBeenCalledOnceWith();
-            expect(deps.trackController.reset).toHaveBeenCalledOnceWith();
+            expect(deps.trackController.reset).toHaveBeenCalledOnceWith(false);
+        });
+        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', () => {
@@ -609,6 +731,21 @@ describe('VinylPlayer', () => {
             });
         });
     });
+    describe('seekRange', () => {
+        it('returns null when no track is loaded', () => {
+            const player = createVinylPlayer(mockOptions, depFactories);
+            expect(player.seekRange).toBeNull();
+            player.dispose();
+        });
+        it('delegates to the current track seekRange', () => {
+            const player = createVinylPlayer(mockOptions, depFactories);
+            const track = new MockTrack();
+            track.seekRange = { start: 0, end: 120 };
+            deps.trackController.activeTrack = track;
+            expect(player.seekRange).toEqual({ start: 0, end: 120 });
+            player.dispose();
+        });
+    });
     describe('disposed', () => {
         it('returns true if the player is disposed', () => {
             const player = createVinylPlayer(mockOptions, depFactories);

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":""}