@amazon/vinyl 1.0.0

package/dist/unit/types/current/track/hls/createHlsContentTypesValue.test.js

@@ -0,0 +1,176 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createHlsContentTypesValue, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
+describe('createHlsContentTypesValue', () => {
+    let manifestData;
+    let deps;
+    beforeEach(() => {
+        manifestData = data(Promise.resolve(mockHlsManifestData));
+        deps = { manifestTransformed: manifestData };
+    });
+    function setMainPlaylist(mainPlaylist) {
+        manifestData.value = Promise.resolve({
+            ...mockHlsManifestData,
+            mainPlaylist,
+        });
+    }
+    it('returns audio and video for mixed codecs', async () => {
+        setMainPlaylist({
+            variants: [
+                {
+                    bandwidth: 1000,
+                    uri: 'v.m3u8',
+                    codecs: 'avc1.640015,mp4a.40.2',
+                },
+            ],
+            alternativeRenditions: [],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['video', 'audio']));
+    });
+    it('returns audio only for audio-only codecs', async () => {
+        setMainPlaylist({
+            variants: [
+                { bandwidth: 128000, uri: 'a.m3u8', codecs: 'mp4a.40.2' },
+            ],
+            alternativeRenditions: [],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['audio']));
+    });
+    it('returns video only for video-only codecs', async () => {
+        setMainPlaylist({
+            variants: [
+                { bandwidth: 1000, uri: 'v.m3u8', codecs: 'avc1.640015' },
+            ],
+            alternativeRenditions: [],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['video']));
+    });
+    it('returns empty set when no variants', async () => {
+        setMainPlaylist({
+            variants: [],
+            alternativeRenditions: [],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set());
+    });
+    it('excludes text content type from codecs', async () => {
+        setMainPlaylist({
+            variants: [{ bandwidth: 1000, uri: 'v.m3u8', codecs: 'stpp' }],
+            alternativeRenditions: [],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set());
+    });
+    it('adds audio from AUDIO renditions', async () => {
+        setMainPlaylist({
+            variants: [
+                { bandwidth: 1000, uri: 'v.m3u8', codecs: 'avc1.640015' },
+            ],
+            alternativeRenditions: [
+                {
+                    type: 'AUDIO',
+                    groupId: 'aud1',
+                    name: 'English',
+                    uri: 'audio.m3u8',
+                },
+            ],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['video', 'audio']));
+    });
+    it('adds video from VIDEO renditions', async () => {
+        setMainPlaylist({
+            variants: [
+                { bandwidth: 128000, uri: 'a.m3u8', codecs: 'mp4a.40.2' },
+            ],
+            alternativeRenditions: [
+                {
+                    type: 'VIDEO',
+                    groupId: 'vid1',
+                    name: 'Camera 1',
+                    uri: 'video.m3u8',
+                },
+            ],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+    it('ignores SUBTITLES renditions', async () => {
+        setMainPlaylist({
+            variants: [
+                { bandwidth: 1000, uri: 'v.m3u8', codecs: 'avc1.640015' },
+            ],
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'sub1',
+                    name: 'English',
+                    uri: 'subs.m3u8',
+                },
+            ],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['video']));
+    });
+    it('ignores CLOSED-CAPTIONS renditions', async () => {
+        setMainPlaylist({
+            variants: [
+                { bandwidth: 1000, uri: 'v.m3u8', codecs: 'avc1.640015' },
+            ],
+            alternativeRenditions: [
+                {
+                    type: 'CLOSED-CAPTIONS',
+                    groupId: 'cc1',
+                    name: 'English',
+                },
+            ],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['video']));
+    });
+    it('deduplicates content types across variants', async () => {
+        setMainPlaylist({
+            variants: [
+                {
+                    bandwidth: 500,
+                    uri: 'low.m3u8',
+                    codecs: 'avc1.640015,mp4a.40.2',
+                },
+                {
+                    bandwidth: 1000,
+                    uri: 'high.m3u8',
+                    codecs: 'avc1.64001e,mp4a.40.2',
+                },
+            ],
+            alternativeRenditions: [],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['video', 'audio']));
+    });
+    it('handles variants without codecs', async () => {
+        setMainPlaylist({
+            variants: [{ bandwidth: 1000, uri: 'v.m3u8' }],
+            alternativeRenditions: [],
+            sessionData: [],
+        });
+        const result = await createHlsContentTypesValue(deps).value;
+        expect(result).toEqual(new Set());
+    });
+});

package/dist/unit/types/current/track/hls/createHlsFactories.test.d.ts

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

package/dist/unit/types/current/track/hls/createHlsFactories.test.d.ts.map

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

package/dist/unit/types/current/track/hls/createHlsFactories.test.js

@@ -0,0 +1,76 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createHlsFactories, HlsManifestControllerImpl, MediaSourceControllerImpl, QualitySelectorImpl, } from '@amazon/vinyl';
+import { createMockVinylDependencies } from '@amazon/vinyl/vinylTestUtil';
+import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
+import { createContainer } from '@amazon/vinyl-di';
+import { MockMediaSource, MockMediaSourceGlobal, } from '@amazon/vinyl-util/browserTestUtil';
+var objectContaining = jasmine.objectContaining;
+var any = jasmine.any;
+var createSpy = jasmine.createSpy;
+describe('createHlsFactories', () => {
+    const originalMediaSource = global.MediaSource;
+    const originalManagedMediaSource = global.ManagedMediaSource;
+    let hlsFactoryDeps;
+    let manifestProvider;
+    beforeEach(() => {
+        global.ManagedMediaSource = undefined;
+        global.MediaSource = MockMediaSource;
+        const deps = createMockVinylDependencies();
+        deps.capabilities.canPlayTypeMse.and.returnValue(true);
+        hlsFactoryDeps = deps;
+        manifestProvider =
+            createSpy('manifestProvider').and.resolveTo(mockHlsManifestData);
+    });
+    afterEach(() => {
+        global.MediaSource = originalMediaSource;
+        global.ManagedMediaSource = originalManagedMediaSource;
+        MockMediaSourceGlobal.isTypeSupported.calls.reset();
+    });
+    it('creates factories with external dependencies', () => {
+        const factoryCreator = createHlsFactories(null);
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider,
+        });
+        const deps = createContainer(factories).dependencies;
+        expect(deps).toEqual(objectContaining({
+            segmentRequestInit: undefined,
+            manifestController: any(HlsManifestControllerImpl),
+            mediaSourceFactory: any(Function),
+            mediaQualityMetadataResolver: any(Function),
+            mediaSourceController: any(MediaSourceControllerImpl),
+            createContentStreamFactories: any(Function),
+            contentStreamFactory: any(Function),
+            qualitySelector: any(QualitySelectorImpl),
+        }));
+    });
+    it('provides streaming options to createContentStreamFactories', () => {
+        const factoryCreator = createHlsFactories({
+            streaming: {
+                buffering: {
+                    minBuffer: 3.1,
+                },
+            },
+        });
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider,
+        });
+        const deps = createContainer(factories).dependencies;
+        expect(deps.contentStreamFactory('audio')).toEqual(any(Object));
+    });
+    it('uses createUrlHlsManifestProvider when no manifestProvider given', () => {
+        const factoryCreator = createHlsFactories(null);
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+        });
+        const deps = createContainer(factories).dependencies;
+        expect(deps.manifestController).toEqual(any(HlsManifestControllerImpl));
+    });
+});

package/dist/unit/types/current/track/hls/createUrlHlsManifestProvider.test.d.ts

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

package/dist/unit/types/current/track/hls/createUrlHlsManifestProvider.test.d.ts.map

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

package/dist/unit/types/current/track/hls/createUrlHlsManifestProvider.test.js

@@ -0,0 +1,116 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createUrlHlsManifestProvider, fetchMediaPlaylist } from '@amazon/vinyl';
+import { Abort, requesterWithRetryRef } from '@amazon/vinyl-util';
+import { MockRequester } from '@amazon/vinyl-util/testUtil';
+describe('createUrlHlsManifestProvider', () => {
+    const mainM3u8 = [
+        '#EXTM3U',
+        '#EXT-X-STREAM-INF:BANDWIDTH=500000,CODECS="mp4a.40.2"',
+        'audio.m3u8',
+    ].join('\n');
+    const mediaM3u8 = [
+        '#EXTM3U',
+        '#EXT-X-TARGETDURATION:6',
+        '#EXT-X-PLAYLIST-TYPE:VOD',
+        '#EXTINF:6.0,',
+        'segment0.aac',
+        '#EXT-X-ENDLIST',
+    ].join('\n');
+    let mockRequester;
+    beforeEach(() => {
+        mockRequester = new MockRequester();
+        requesterWithRetryRef.set(() => mockRequester);
+        mockRequester.request.and.callFake((input) => {
+            const url = input instanceof URL ? input.href : String(input);
+            if (url.includes('audio.m3u8')) {
+                return Promise.resolve(new Response(mediaM3u8));
+            }
+            return Promise.resolve(new Response(mainM3u8));
+        });
+    });
+    it('parses the main playlist', async () => {
+        const provider = createUrlHlsManifestProvider('https://example.com/main.m3u8');
+        const data = await provider();
+        expect(data.mainPlaylist.variants.length).toBe(1);
+        expect(data.mainPlaylist.variants[0].bandwidth).toBe(500000);
+    });
+    it('sets the baseUrl from the response URL', async () => {
+        mockRequester.request.and.callFake((_input) => {
+            const resp = new Response(mainM3u8);
+            Object.defineProperty(resp, 'url', {
+                value: 'https://redirected.com/main.m3u8',
+            });
+            return Promise.resolve(resp);
+        });
+        const provider = createUrlHlsManifestProvider('https://example.com/main.m3u8');
+        const data = await provider();
+        expect(data.baseUrl).toBe('https://redirected.com/main.m3u8');
+    });
+    it('lazily fetches media playlists via getMediaPlaylist', async () => {
+        const provider = createUrlHlsManifestProvider('https://example.com/main.m3u8');
+        const data = await provider();
+        // Only the main playlist fetch should have occurred
+        expect(mockRequester.request).toHaveBeenCalledTimes(1);
+        const playlist = await data.getMediaPlaylist('audio.m3u8');
+        expect(playlist.targetDuration).toBe(6);
+        expect(playlist.segments.length).toBe(1);
+        expect(mockRequester.request).toHaveBeenCalledTimes(2);
+    });
+    it('caches media playlist results', async () => {
+        const provider = createUrlHlsManifestProvider('https://example.com/main.m3u8');
+        const data = await provider();
+        const first = await data.getMediaPlaylist('audio.m3u8');
+        const second = await data.getMediaPlaylist('audio.m3u8');
+        expect(first).toBe(second);
+        // Only 1 main + 1 media fetch
+        expect(mockRequester.request).toHaveBeenCalledTimes(2);
+    });
+    it('resolves media playlist URIs relative to main URL', async () => {
+        const provider = createUrlHlsManifestProvider('https://example.com/path/main.m3u8');
+        const data = await provider();
+        await data.getMediaPlaylist('audio.m3u8');
+        const secondCall = mockRequester.request.calls.argsFor(1);
+        expect(String(secondCall[0])).toBe('https://example.com/path/audio.m3u8');
+    });
+    it('passes requestInit to requests', async () => {
+        const requestInit = { headers: { Authorization: 'Bearer token' } };
+        const provider = createUrlHlsManifestProvider('https://example.com/main.m3u8', requestInit);
+        await provider();
+        expect(mockRequester.request.calls.argsFor(0)[1]).toEqual(requestInit);
+    });
+    it('passes abort to requests', async () => {
+        const provider = createUrlHlsManifestProvider('https://example.com/main.m3u8');
+        const abort = new Abort();
+        await provider(abort);
+        expect(mockRequester.request.calls.argsFor(0)[2]).toEqual(jasmine.objectContaining({ abort }));
+    });
+});
+describe('fetchMediaPlaylist', () => {
+    const mediaM3u8 = [
+        '#EXTM3U',
+        '#EXT-X-TARGETDURATION:6',
+        '#EXT-X-PLAYLIST-TYPE:VOD',
+        '#EXTINF:6.0,',
+        'segment0.aac',
+        '#EXT-X-ENDLIST',
+    ].join('\n');
+    let mockRequester;
+    beforeEach(() => {
+        mockRequester = new MockRequester();
+        requesterWithRetryRef.set(() => mockRequester);
+        mockRequester.request.and.callFake(() => Promise.resolve(new Response(mediaM3u8)));
+    });
+    it('fetches and parses a media playlist', async () => {
+        const playlist = await fetchMediaPlaylist({
+            uri: 'audio.m3u8',
+            baseUrl: 'https://example.com/path/main.m3u8',
+            defines: undefined,
+        });
+        expect(playlist.targetDuration).toBe(6);
+        expect(playlist.segments.length).toBe(1);
+        expect(String(mockRequester.request.calls.argsFor(0)[0])).toBe('https://example.com/path/audio.m3u8');
+    });
+});

package/dist/unit/types/current/track/hls/util/hlsByteRangeToMediaRange.test.d.ts

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

package/dist/unit/types/current/track/hls/util/hlsByteRangeToMediaRange.test.d.ts.map

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

package/dist/unit/types/current/track/hls/util/hlsByteRangeToMediaRange.test.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { hlsByteRangeToMediaRange } from '@amazon/vinyl';
+describe('hlsByteRangeToMediaRange', () => {
+    it('converts HLS byte range to media range', () => {
+        expect(hlsByteRangeToMediaRange({ offset: 100, length: 200 })).toEqual([
+            100, 299,
+        ]);
+    });
+    it('handles zero offset', () => {
+        expect(hlsByteRangeToMediaRange({ offset: 0, length: 50 })).toEqual([
+            0, 49,
+        ]);
+    });
+    it('handles length of 1', () => {
+        expect(hlsByteRangeToMediaRange({ offset: 10, length: 1 })).toEqual([
+            10, 10,
+        ]);
+    });
+});

package/dist/unit/types/current/track/hls/util/hlsSegmentTime.test.d.ts

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

package/dist/unit/types/current/track/hls/util/hlsSegmentTime.test.d.ts.map

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

package/dist/unit/types/current/track/hls/util/hlsSegmentTime.test.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { buildSegmentTimeline } from '@amazon/vinyl';
+var createSpy = jasmine.createSpy;
+describe('buildSegmentTimeline', () => {
+    const deps = {
+        requestInterceptor: createSpy('requestInterceptor'),
+        segmentRequestInit: undefined,
+    };
+    const baseUrl = 'https://example.com/media/';
+    function segment(uri, duration, byteRange) {
+        return {
+            uri,
+            duration,
+            sequenceNumber: 0,
+            discontinuity: false,
+            ...(byteRange && { byteRange }),
+        };
+    }
+    it('returns empty array for empty segments', () => {
+        expect(buildSegmentTimeline(deps, baseUrl, [])).toEqual([]);
+    });
+    it('builds cumulative start and end times', () => {
+        const segments = [
+            segment('seg0.mp4', 6),
+            segment('seg1.mp4', 4),
+            segment('seg2.mp4', 5),
+        ];
+        const timeline = buildSegmentTimeline(deps, baseUrl, segments);
+        expect(timeline.length).toBe(3);
+        expect(timeline[0].startTime).toBe(0);
+        expect(timeline[0].endTime).toBe(6);
+        expect(timeline[1].startTime).toBe(6);
+        expect(timeline[1].endTime).toBe(10);
+        expect(timeline[2].startTime).toBe(10);
+        expect(timeline[2].endTime).toBe(15);
+    });
+    it('sets timestampOffset equal to startTime', () => {
+        const segments = [segment('seg0.mp4', 6), segment('seg1.mp4', 4)];
+        const timeline = buildSegmentTimeline(deps, baseUrl, segments);
+        expect(timeline[0].timestampOffset).toBe(0);
+        expect(timeline[1].timestampOffset).toBe(6);
+    });
+    it('creates a data provider for each segment', () => {
+        const segments = [segment('seg0.mp4', 6)];
+        const timeline = buildSegmentTimeline(deps, baseUrl, segments);
+        expect(typeof timeline[0].data).toBe('function');
+    });
+    it('passes byteRange as mediaRange when present', () => {
+        const segments = [segment('seg0.mp4', 6, { offset: 100, length: 200 })];
+        const timeline = buildSegmentTimeline(deps, baseUrl, segments);
+        expect(typeof timeline[0].data).toBe('function');
+    });
+});

package/dist/unit/types/current/track/mse/codec.test.d.ts

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

package/dist/unit/types/current/track/mse/codec.test.d.ts.map

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

package/dist/unit/types/current/track/mse/codec.test.js

@@ -0,0 +1,100 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { codecToContentType, codecsToContentTypes, contentTypeToMimeType, } from '@amazon/vinyl';
+describe('codec', () => {
+    describe('codecToContentType', () => {
+        it('returns video for avc1', () => {
+            expect(codecToContentType('avc1.640015')).toBe('video');
+        });
+        it('returns video for avc3', () => {
+            expect(codecToContentType('avc3.640015')).toBe('video');
+        });
+        it('returns video for hvc1', () => {
+            expect(codecToContentType('hvc1.1.6.L93.B0')).toBe('video');
+        });
+        it('returns video for hev1', () => {
+            expect(codecToContentType('hev1.1.6.L93.B0')).toBe('video');
+        });
+        it('returns video for vp09', () => {
+            expect(codecToContentType('vp09.00.10.08')).toBe('video');
+        });
+        it('returns video for av01', () => {
+            expect(codecToContentType('av01.0.01M.08')).toBe('video');
+        });
+        it('returns video for dvh1', () => {
+            expect(codecToContentType('dvh1.05.06')).toBe('video');
+        });
+        it('returns video for dvhe', () => {
+            expect(codecToContentType('dvhe.05.06')).toBe('video');
+        });
+        it('returns audio for mp4a', () => {
+            expect(codecToContentType('mp4a.40.2')).toBe('audio');
+        });
+        it('returns audio for ac-3', () => {
+            expect(codecToContentType('ac-3')).toBe('audio');
+        });
+        it('returns audio for ec-3', () => {
+            expect(codecToContentType('ec-3')).toBe('audio');
+        });
+        it('returns audio for opus', () => {
+            expect(codecToContentType('opus')).toBe('audio');
+        });
+        it('returns audio for fLaC', () => {
+            expect(codecToContentType('fLaC')).toBe('audio');
+        });
+        it('returns text for stpp', () => {
+            expect(codecToContentType('stpp')).toBe('text');
+        });
+        it('returns text for wvtt', () => {
+            expect(codecToContentType('wvtt')).toBe('text');
+        });
+        it('returns null for unknown codec', () => {
+            expect(codecToContentType('unknown.codec')).toBeNull();
+        });
+        it('trims whitespace', () => {
+            expect(codecToContentType('  mp4a.40.2  ')).toBe('audio');
+        });
+        it('is case insensitive', () => {
+            expect(codecToContentType('MP4A.40.2')).toBe('audio');
+            expect(codecToContentType('AVC1.640015')).toBe('video');
+            expect(codecToContentType('FLAC')).toBe('audio');
+            expect(codecToContentType('STPP')).toBe('text');
+        });
+    });
+    describe('codecsToContentTypes', () => {
+        it('returns audio and video for mixed codecs', () => {
+            expect(codecsToContentTypes('avc1.640015,mp4a.40.2')).toEqual(new Set(['video', 'audio']));
+        });
+        it('returns audio only for audio codec', () => {
+            expect(codecsToContentTypes('mp4a.40.2')).toEqual(new Set(['audio']));
+        });
+        it('returns video only for video codec', () => {
+            expect(codecsToContentTypes('avc1.640015')).toEqual(new Set(['video']));
+        });
+        it('returns empty set for unknown codecs', () => {
+            expect(codecsToContentTypes('unknown')).toEqual(new Set());
+        });
+        it('deduplicates content types', () => {
+            expect(codecsToContentTypes('avc1.640015,avc1.64001e')).toEqual(new Set(['video']));
+        });
+    });
+    describe('contentTypeToMimeType', () => {
+        it('returns video/mp4 with codecs for video', () => {
+            expect(contentTypeToMimeType('video', 'avc1.640015')).toBe('video/mp4; codecs="avc1.640015"');
+        });
+        it('returns audio/mp4 with codecs for audio', () => {
+            expect(contentTypeToMimeType('audio', 'mp4a.40.2')).toBe('audio/mp4; codecs="mp4a.40.2"');
+        });
+        it('returns audio/mp4 with codecs for text', () => {
+            expect(contentTypeToMimeType('text', 'wvtt')).toBe('audio/mp4; codecs="wvtt"');
+        });
+        it('returns video/mp4 without codecs when null', () => {
+            expect(contentTypeToMimeType('video', null)).toBe('video/mp4');
+        });
+        it('returns audio/mp4 without codecs when null', () => {
+            expect(contentTypeToMimeType('audio', null)).toBe('audio/mp4');
+        });
+    });
+});

package/dist/unit/types/current/track/source/FixedPlaybackQuality.test.d.ts

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

package/dist/unit/types/current/track/source/FixedPlaybackQuality.test.d.ts.map

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