@amazon/vinyl 1.0.0

package/dist/unit/types/current/track/dash/urlDashManifestProvider.test.d.ts

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

package/dist/unit/types/current/track/dash/urlDashManifestProvider.test.d.ts.map

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

package/dist/unit/types/current/track/dash/urlDashManifestProvider.test.js

@@ -0,0 +1,102 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { urlDashManifestProvider } from '@amazon/vinyl';
+import { Abort, isNode, requesterWithRetryRef, } from '@amazon/vinyl-util';
+import { dash_segmentBase } from '@amazon/vinyl/vinylTestUtil';
+import { MockRequester } from '@amazon/vinyl-util/testUtil';
+var any = jasmine.any;
+describe('urlDashManifestProvider', () => {
+    let mockRequester;
+    function initMockResponse() {
+        mockRequester.request.and.resolveTo(new Response(dash_segmentBase));
+    }
+    beforeEach(() => {
+        mockRequester = new MockRequester();
+        requesterWithRetryRef.set(() => mockRequester);
+        initMockResponse();
+    });
+    it('returns a Promise for the dash manifest at the given url', async () => {
+        const init = { method: 'GET' };
+        const provider = urlDashManifestProvider('https://example.com', init);
+        const abort = new Abort();
+        const { manifest, baseUrl } = await provider(abort);
+        expect(mockRequester.request).toHaveBeenCalledOnceWith('https://example.com', init, { abort });
+        expect(baseUrl).toBe('https://example.com/');
+        expect(manifest.MPD).toEqual(any(Object));
+    });
+    describe('when input url is absolute', () => {
+        it('provides the input url as the base url', async () => {
+            {
+                const provider = urlDashManifestProvider('https://example.com/foo/myManifest.mpd');
+                expect((await provider()).baseUrl).toEqual('https://example.com/foo/');
+            }
+            {
+                const provider = urlDashManifestProvider('https://example.com/foo/myManifest.mpd');
+                initMockResponse();
+                expect((await provider()).baseUrl).toEqual('https://example.com/foo/');
+            }
+        });
+        it('uses response.url for baseUrl when redirected', async () => {
+            mockRequester.request.and.callFake(() => {
+                const resp = new Response(dash_segmentBase);
+                Object.defineProperty(resp, 'url', {
+                    value: 'https://redirected.com/bar/myManifest.mpd',
+                });
+                return Promise.resolve(resp);
+            });
+            const provider = urlDashManifestProvider('https://example.com/foo/myManifest.mpd');
+            expect((await provider()).baseUrl).toEqual('https://redirected.com/bar/');
+        });
+    });
+    describe('when requestInterceptor is provided', () => {
+        it('transforms the request parameters before fetching', async () => {
+            const provider = urlDashManifestProvider('https://example.com/foo/myManifest.mpd', {}, (params) => {
+                params.input += '?added=value';
+                params.init.headers = {
+                    myHeader: 'myHeaderValue',
+                };
+            });
+            await provider();
+            expect(mockRequester.request).toHaveBeenCalledOnceWith('https://example.com/foo/myManifest.mpd?added=value', {
+                headers: {
+                    myHeader: 'myHeaderValue',
+                },
+            }, any(Object));
+        });
+    });
+    describe('when input url is relative', () => {
+        beforeEach(() => {
+            if (!isNode())
+                return pending('requires node environment to test');
+            global.location = {
+                origin: 'https://example.com',
+                href: 'https://example.com/',
+            };
+        });
+        afterEach(() => {
+            if (isNode())
+                delete global.location;
+        });
+        it('provides a baseUrl as absolute, relative to the origin', async () => {
+            const provider = urlDashManifestProvider('./foo/myManifest.mpd');
+            expect((await provider()).baseUrl).toEqual('https://example.com/foo/');
+        });
+        describe('when location is undefined', () => {
+            // Only relevant for NODE
+            beforeEach(() => {
+                if (!isNode())
+                    return pending('requires node environment to test');
+                delete global.location;
+            });
+            it('resolves input against empty base', async () => {
+                const provider = urlDashManifestProvider('./foo/myManifest.mpd');
+                // Without URL construction, no validation occurs on the input string.
+                // The provider proceeds with a path resolved against an empty base.
+                const { manifest } = await provider();
+                expect(manifest.MPD).toEqual(any(Object));
+            });
+        });
+    });
+});

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

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

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

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

package/dist/unit/types/current/track/dash/util/mimeType.test.js

@@ -0,0 +1,174 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getRepresentationMimeInfo } from '@amazon/vinyl';
+import { clone } from '@amazon/vinyl-util';
+import { mockDashManifest } from '@amazon/vinyl/vinylTestUtil';
+describe('getRepresentationMimeInfo', () => {
+    let manifest;
+    let adaptationSet;
+    let representation;
+    beforeEach(() => {
+        manifest = clone(mockDashManifest);
+        adaptationSet = manifest.MPD.Period[0].AdaptationSet[0];
+        representation = adaptationSet.Representation[0];
+    });
+    describe('when mimeType and codecs is present on the representation', () => {
+        beforeEach(() => {
+            representation.codecs = 'mp4a.40.2';
+            representation.mimeType = 'audio/mp4';
+        });
+        it('composes the mimeType and codecs of the representation', () => {
+            const info = getRepresentationMimeInfo(representation);
+            expect(info).toEqual({
+                mimeType: 'audio/mp4; codecs="mp4a.40.2"',
+                contentType: 'audio',
+            });
+        });
+    });
+    describe('when mimeType is present on the adaptation set and not on the representation', () => {
+        beforeEach(() => {
+            adaptationSet.mimeType = 'audio/mp4';
+            adaptationSet.codecs = 'mp4a.40.2';
+        });
+        it('uses the adaptation set mimeType and codecs', () => {
+            const info = getRepresentationMimeInfo(representation);
+            expect(info).toEqual({
+                mimeType: 'audio/mp4; codecs="mp4a.40.2"',
+                contentType: 'audio',
+            });
+        });
+    });
+    describe('when mimeType is present on both the adaptation set and the representation', () => {
+        beforeEach(() => {
+            adaptationSet.mimeType = 'notExpectedMimeType';
+            representation.mimeType = 'video/mp4';
+        });
+        it('uses the representation mimeType and codecs', () => {
+            adaptationSet.codecs = 'notExpectedCodecs';
+            representation.codecs = 'avc1';
+            const info = getRepresentationMimeInfo(representation);
+            expect(info).toEqual({
+                mimeType: 'video/mp4; codecs="avc1"',
+                contentType: 'video',
+            });
+        });
+        describe('when codecs is not present', () => {
+            it('uses just the mimeType', () => {
+                const info = getRepresentationMimeInfo(representation);
+                expect(info).toEqual({
+                    mimeType: 'video/mp4',
+                    contentType: 'video',
+                });
+            });
+        });
+    });
+    describe('when mimeType is not set', () => {
+        describe('and contentType is set', () => {
+            it('infers mime type from content type', () => {
+                adaptationSet.contentType = 'audio';
+                adaptationSet.codecs = 'flac';
+                expect(getRepresentationMimeInfo(representation)).toEqual({
+                    mimeType: 'audio/mp4; codecs="flac"',
+                    contentType: 'audio',
+                });
+                adaptationSet.contentType = 'video';
+                adaptationSet.codecs = 'avc1';
+                expect(getRepresentationMimeInfo(representation)).toEqual({
+                    mimeType: 'video/mp4; codecs="avc1"',
+                    contentType: 'video',
+                });
+            });
+        });
+        describe('and contentType is not set but codecs is', () => {
+            it('infers content type from codec', () => {
+                adaptationSet.codecs = 'mp4a.40.2';
+                expect(getRepresentationMimeInfo(representation)).toEqual({
+                    mimeType: 'audio/mp4; codecs="mp4a.40.2"',
+                    contentType: 'audio',
+                });
+            });
+            it('infers video content type from codec', () => {
+                adaptationSet.codecs = 'avc1.640015';
+                expect(getRepresentationMimeInfo(representation)).toEqual({
+                    mimeType: 'video/mp4; codecs="avc1.640015"',
+                    contentType: 'video',
+                });
+            });
+        });
+        describe('and contentType is not set and codecs is not set', () => {
+            it('returns null mimeType', () => {
+                expect(getRepresentationMimeInfo(representation)).toEqual({
+                    mimeType: null,
+                    contentType: null,
+                });
+            });
+        });
+        describe('and contentType is not set and codec is unrecognised', () => {
+            it('returns null mimeType', () => {
+                adaptationSet.codecs = 'unknown';
+                expect(getRepresentationMimeInfo(representation)).toEqual({
+                    mimeType: null,
+                    contentType: null,
+                });
+            });
+        });
+    });
+    describe('content type inference from mimeType', () => {
+        it('infers audio from audio/ mimeType', () => {
+            representation.mimeType = 'audio/mp4';
+            const info = getRepresentationMimeInfo(representation);
+            expect(info.contentType).toBe('audio');
+        });
+        it('infers video from video/ mimeType', () => {
+            representation.mimeType = 'video/mp4';
+            const info = getRepresentationMimeInfo(representation);
+            expect(info.contentType).toBe('video');
+        });
+        it('infers text from text/ mimeType', () => {
+            representation.mimeType = 'text/vtt';
+            const info = getRepresentationMimeInfo(representation);
+            expect(info.contentType).toBe('text');
+        });
+        it('infers text from application/json', () => {
+            representation.mimeType = 'application/json';
+            const info = getRepresentationMimeInfo(representation);
+            expect(info.contentType).toBe('text');
+        });
+        it('infers text from application/xml', () => {
+            representation.mimeType = 'application/xml';
+            const info = getRepresentationMimeInfo(representation);
+            expect(info.contentType).toBe('text');
+        });
+        it('returns null contentType for unknown mimeType', () => {
+            representation.mimeType = 'application/octet-stream';
+            const info = getRepresentationMimeInfo(representation);
+            expect(info.contentType).toBeNull();
+        });
+        it('prefers adaptationSet contentType over inference', () => {
+            representation.mimeType = 'audio/mp4';
+            adaptationSet.contentType = 'video';
+            const info = getRepresentationMimeInfo(representation);
+            expect(info.contentType).toBe('video');
+        });
+    });
+    describe('when mimeType is not set and contentType is audio without codecs', () => {
+        it('returns mimeType without codecs', () => {
+            adaptationSet.contentType = 'audio';
+            expect(getRepresentationMimeInfo(representation)).toEqual({
+                mimeType: 'audio/mp4',
+                contentType: 'audio',
+            });
+        });
+    });
+    describe('when mimeType is not set and contentType is video without codecs', () => {
+        it('returns mimeType without codecs', () => {
+            adaptationSet.contentType = 'video';
+            expect(getRepresentationMimeInfo(representation)).toEqual({
+                mimeType: 'video/mp4',
+                contentType: 'video',
+            });
+        });
+    });
+});

package/dist/unit/types/current/track/dash/util/mpd.test.d.ts

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

package/dist/unit/types/current/track/dash/util/mpd.test.d.ts.map

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

package/dist/unit/types/current/track/dash/util/mpd.test.js

@@ -0,0 +1,312 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { calculateDuration, calculatePeriodEnd, calculatePeriodStart, calculatePeriodTimeRange, flattenRepresentations, getPeriodAtTime, getRepresentationAncestry, getSegmentBase, getSegmentList, getSegmentTemplate, sampleToMpdTime, } from '@amazon/vinyl';
+import { clone, toJson } from '@amazon/vinyl-util';
+import { parseDashManifest } from '@amazon/vinyl-mpd-parser';
+import { mockDashManifest } from '@amazon/vinyl/vinylTestUtil';
+var objectContaining = jasmine.objectContaining;
+describe('mpd utils', () => {
+    describe('getSegmentList', () => {
+        it('combines inherited properties', () => {
+            // language=XML
+            const manifest = parseDashManifest(`<?xml version="1.0" ?>
+            <MPD minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                <Period>
+                    <SegmentList actuate="onRequest" duration="20S"/>
+                    <AdaptationSet>
+                        <SegmentList startNumber="1"/>
+                        <Representation id="0" bandwidth="2345">
+                            <SegmentList actuate="onLoad">
+                                <SegmentURL media="mediaExample"/>
+                            </SegmentList>
+                        </Representation>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+            const rep = manifest.MPD.Period[0].AdaptationSet[0].Representation[0];
+            expect(toJson(getSegmentList(rep))).toEqual({
+                actuate: 'onLoad',
+                duration: 20,
+                indexRangeExact: false,
+                startNumber: 1,
+                SegmentURL: [{ media: 'mediaExample' }],
+            });
+        });
+        describe('when undefined at each scope', () => {
+            it('returns undefined', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+            <MPD minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                <Period>
+                    <AdaptationSet>
+                        <Representation id="0" bandwidth="2345"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+                const rep = manifest.MPD.Period[0].AdaptationSet[0].Representation[0];
+                expect(getSegmentList(rep)).toBeUndefined();
+            });
+        });
+    });
+    describe('getSegmentTemplate', () => {
+        it('combines inherited properties', () => {
+            // language=XML
+            const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD mediaPresentationDuration="25S" minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period start="0S">
+      <SegmentTemplate bitstreamSwitching="true"/>
+      <AdaptationSet>
+          <SegmentTemplate media="adaptationSetMedia" initialization="adaptationSetInitialization"/>
+          <Representation id="0" bandwidth="2345">
+              <SegmentTemplate media="representationSetMedia"/>
+          </Representation>
+      </AdaptationSet>
+  </Period>
+</MPD>`);
+            const rep = manifest.MPD.Period[0].AdaptationSet[0].Representation[0];
+            expect(toJson(getSegmentTemplate(rep))).toEqual({
+                bitstreamSwitching: 'true',
+                indexRangeExact: false,
+                media: 'representationSetMedia',
+                initialization: 'adaptationSetInitialization',
+            });
+        });
+    });
+    describe('getSegmentBase', () => {
+        it('combines inherited properties', () => {
+            // language=XML
+            const manifest = parseDashManifest(`<?xml version="1.0" ?>
+            <MPD mediaPresentationDuration="25S" minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                <Period start="0S">
+                    <SegmentBase indexRange="123-456" duration="20S"/>
+                    <AdaptationSet>
+                        <SegmentBase presentationTimeOffset="2456"/>
+                        <Representation id="0" bandwidth="2345">
+                            <SegmentBase>
+                                <Initialization range="111-222"/>
+                            </SegmentBase>
+                        </Representation>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+            const rep = manifest.MPD.Period[0].AdaptationSet[0].Representation[0];
+            expect(toJson(getSegmentBase(rep))).toEqual({
+                indexRange: [123, 456],
+                indexRangeExact: false,
+                presentationTimeOffset: 2456,
+                Initialization: {
+                    range: [111, 222],
+                },
+            });
+        });
+    });
+    describe('calculatePeriodTimeRange', () => {
+        it('returns the start and end presentation time range of the given period', () => {
+            // language=XML
+            const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD mediaPresentationDuration="25S" minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period start="0S"/>
+  <Period start="11S"/>
+  <Period start="13S"/>
+  <Period start="18S"/>
+</MPD>`);
+            expect(manifest.MPD.Period.map(calculatePeriodTimeRange)).toEqual([
+                [0, 11],
+                [11, 13],
+                [13, 18],
+                [18, 25],
+            ]);
+        });
+    });
+    describe('calculatePeriodStart', () => {
+        describe('when period.start is defined', () => {
+            it('uses period.start', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+                <MPD mediaPresentationDuration="25S" minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                    <Period start="0S"/>
+                    <Period start="11S"/>
+                    <Period start="13S"/>
+                    <Period start="18S"/>
+                </MPD>`);
+                expect(manifest.MPD.Period.map(calculatePeriodStart)).toEqual([
+                    0, 11, 13, 18,
+                ]);
+            });
+        });
+        describe('when period.start is not defined', () => {
+            it('returns 0', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD mediaPresentationDuration="PT5M0.0S" minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period duration="10S"/>
+</MPD>`);
+                expect(calculatePeriodStart(manifest.MPD.Period[0])).toEqual(0);
+            });
+        });
+    });
+    describe('getPeriodAtTime', () => {
+        it('returns the period spanning the given presentation time', () => {
+            // language=XML
+            const manifest = parseDashManifest(`<?xml version="1.0" ?>
+            <MPD mediaPresentationDuration="60S" minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                <Period start="0S" id="0"/>
+                <Period start="11S" id="1"/>
+                <Period start="13S" id="2"/>
+                <Period start="18S" id="3"/>
+                <Period start="23S" id="4"/>
+                <Period start="56S" id="5"/>
+            </MPD>`);
+            function id(time) {
+                return getPeriodAtTime(manifest, time)?.id ?? null;
+            }
+            expect(id(-1)).toBeNull();
+            expect(id(0)).toEqual('0');
+            expect(id(10)).toEqual('0');
+            expect(id(11)).toEqual('1');
+            expect(id(55.99)).toEqual('4');
+            expect(id(56)).toEqual('5');
+            expect(id(59.99)).toEqual('5');
+            expect(id(600)).toBeNull();
+            expect(id(60)).toBeNull();
+        });
+    });
+    describe('sampleToMpdTime', () => {
+        it('converts a sample time to an MPD-relative time.', () => {
+            expect(sampleToMpdTime(9000, 10, 3000, 1000)).toEqual(16);
+        });
+    });
+    describe('getRepresentationAncestry', () => {
+        it('returns the representation MPD, Period, AdaptationSet, Representation ancestry of a Representation', () => {
+            // language=XML
+            const manifest = parseDashManifest(`<?xml version="1.0" ?>
+            <MPD id="m0" minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                <Period id="p0">
+                    <AdaptationSet id="0">
+                        <Representation id="r0" bandwidth="1"/>
+                        <Representation id="r1" bandwidth="1"/>
+                    </AdaptationSet>
+                    <AdaptationSet id="1">
+                        <Representation id="r2" bandwidth="1"/>
+                        <Representation id="r3" bandwidth="1"/>
+                    </AdaptationSet>
+                </Period>
+                <Period id="p1">
+                    <AdaptationSet id="2">
+                        <Representation id="r4" bandwidth="1"/>
+                        <Representation id="r5" bandwidth="1"/>
+                    </AdaptationSet>
+                    <AdaptationSet id="3">
+                        <Representation id="r6" bandwidth="1"/>
+                        <Representation id="r7" bandwidth="1"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+            expect(getRepresentationAncestry(manifest.MPD.Period[0].AdaptationSet[0].Representation[0]).map((element) => element.id)).toEqual([
+                'm0',
+                'p0',
+                0, // To spec: adaptation sets use uint IDs
+                'r0',
+            ]);
+            expect(getRepresentationAncestry(manifest.MPD.Period[1].AdaptationSet[1].Representation[1]).map((element) => element.id)).toEqual(['m0', 'p1', 3, 'r7']);
+        });
+    });
+    describe('calculatePeriodEnd', () => {
+        describe('when period start and duration are set', () => {
+            it('returns period start plus duration', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+            <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                <Period start="23" duration="30"/>
+            </MPD>`);
+                expect(calculatePeriodEnd(manifest.MPD.Period[0])).toEqual(53);
+            });
+        });
+        describe('when period is not last', () => {
+            it('returns start of next period', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+                <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                    <Period start="23"/>
+                    <Period start="52"/>
+                    <Period start="64"/>
+                </MPD>`);
+                expect(calculatePeriodEnd(manifest.MPD.Period[0])).toEqual(52);
+                expect(calculatePeriodEnd(manifest.MPD.Period[1])).toEqual(64);
+            });
+        });
+        describe('when period is last', () => {
+            it('returns manifest presentation duration', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+                <MPD mediaPresentationDuration="25S" minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                    <Period/>
+                </MPD>`);
+                expect(calculatePeriodEnd(manifest.MPD.Period[0])).toEqual(25);
+            });
+            describe('when the manifest presentation duration is not set', () => {
+                it('returns null', () => {
+                    // language=XML
+                    const manifest = parseDashManifest(`<?xml version="1.0" ?>
+                <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                    <Period/>
+                </MPD>`);
+                    expect(calculatePeriodEnd(manifest.MPD.Period[0])).toBeNull();
+                });
+            });
+        });
+    });
+    describe('flattenRepresentations', () => {
+        it('returns a flattened list of all representations across all periods', () => {
+            // language=XML
+            const manifest = parseDashManifest(`<?xml version="1.0" ?>
+                <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                    <Period>
+                        <AdaptationSet id="1">
+                            <Representation bandwidth="1" id="1a"/>
+                            <Representation bandwidth="2" id="1b"/>
+                        </AdaptationSet>
+                        <AdaptationSet id="2">
+                            <Representation bandwidth="3" id="2a"/>
+                            <Representation bandwidth="4" id="2b"/>
+                        </AdaptationSet>
+                        <AdaptationSet id="3">
+                            <Representation bandwidth="5" id="3a"/>
+                            <Representation bandwidth="6" id="3b"/>
+                        </AdaptationSet>
+                    </Period>
+                </MPD>`);
+            expect(toJson(flattenRepresentations(manifest.MPD.Period[0]))).toEqual(objectContaining([
+                { bandwidth: 1, id: '1a' },
+                { bandwidth: 2, id: '1b' },
+                { bandwidth: 3, id: '2a' },
+                { bandwidth: 4, id: '2b' },
+                { bandwidth: 5, id: '3a' },
+                { bandwidth: 6, id: '3b' },
+            ]));
+        });
+    });
+    describe('calculateDuration', () => {
+        describe('when MPD.mediaPresentationDuration is set', () => {
+            it('resolves to MPD.mediaPresentationDuration', () => {
+                const manifest = clone(mockDashManifest);
+                manifest.MPD.mediaPresentationDuration = 65;
+                expect(calculateDuration(manifest)).toBe(65);
+            });
+        });
+        describe('when MPD.mediaPresentationDuration is not set', () => {
+            it('resolves to calculated period end', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-live:2011" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period/>
+  <Period start="20" duration="30">
+  </Period>
+</MPD>`);
+                expect(calculateDuration(manifest)).toBe(50);
+            });
+        });
+    });
+});

package/dist/unit/types/current/track/dash/util/uriResolution.test.d.ts

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

package/dist/unit/types/current/track/dash/util/uriResolution.test.d.ts.map

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