@amazon/vinyl 1.0.0

package/dist/unit/types/current/drm/commonEme/WebKitCommonEme.test.js

@@ -0,0 +1,297 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DrmError, DrmKeySystem, MediaKeySessionErrorType, WebKitCommonEme, WebKitCommonMediaKeys, WebKitCommonMediaKeySession, WebKitCommonMediaKeySystemAccess, webkitErrorCodeToStr, } from '@amazon/vinyl';
+import { DisposedError, isNode, utf16ToUint16Array } from '@amazon/vinyl-util';
+import { expectTypeEquals, implementEventFakes, MockHTMLAudioElement, mockEvent, } from '@amazon/vinyl-util/browserTestUtil';
+import { MockWebKitMediaKeyError, MockWebKitMediaKeyMessageEvent, MockWebKitMediaKeys, MockWebKitMediaKeySession, } from '@amazon/vinyl/vinylTestUtil';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+var createSpy = jasmine.createSpy;
+describe('WebkitCommonEme', () => {
+    beforeEach(() => {
+        if (!isNode())
+            pending('Cannot mock WebKit outside Node');
+        global.WebKitMediaKeys = MockWebKitMediaKeys;
+        global.WebKitMediaKeySession = MockWebKitMediaKeySession;
+        global.WebKitMediaKeyError = MockWebKitMediaKeyError;
+    });
+    afterEach(() => {
+        delete global.WebKitMediaKeys;
+        delete global.WebKitMediaKeySession;
+        delete global.WebKitMediaKeyError;
+    });
+    describe('WebKitCommonEme', () => {
+        // intersection type is to get the global legacy interface extensions
+        let mockAudioElement;
+        let mockAudioElementEventFakes;
+        let webKitCommonEme;
+        beforeEach(() => {
+            mockAudioElement = new MockHTMLAudioElement();
+            mockAudioElement.webkitSetMediaKeys =
+                createSpy('webkitSetMediaKeys');
+            mockAudioElementEventFakes = implementEventFakes(mockAudioElement);
+            webKitCommonEme = new WebKitCommonEme();
+        });
+        describe('requestMediaKeySystemAccess', () => {
+            describe('requests access', () => {
+                const keySystem = DrmKeySystem.WIDEVINE;
+                const supportedConfigurations = [
+                    {
+                        audioCapabilities: [
+                            {
+                                contentType: 'test',
+                            },
+                        ],
+                    },
+                ];
+                describe('with configs', () => {
+                    describe('with audioCapabilities', () => {
+                        describe('when isTypeSupported() returns true', () => {
+                            beforeEach(() => {
+                                MockWebKitMediaKeys.isTypeSupported.and.returnValue(true);
+                            });
+                            it('returns system access object', async () => {
+                                const access = await webKitCommonEme.requestMediaKeySystemAccess(keySystem, supportedConfigurations);
+                                expect(access).toBeInstanceOf(WebKitCommonMediaKeySystemAccess);
+                                expect(access.keySystem).toBe(keySystem);
+                            });
+                        });
+                        describe('when isTypeSupported() returns false', () => {
+                            beforeEach(() => {
+                                MockWebKitMediaKeys.isTypeSupported.and.returnValue(false);
+                            });
+                            it('throws DrmError', async () => {
+                                await expectAsync(webKitCommonEme.requestMediaKeySystemAccess(keySystem, supportedConfigurations)).toBeRejectedWithError(DrmError);
+                            });
+                        });
+                    });
+                    describe('without audioCapabilities', () => {
+                        it('throws error', async () => {
+                            await expectAsync(webKitCommonEme.requestMediaKeySystemAccess(keySystem, [{}])).toBeRejectedWithError(DrmError, `keySystem not supported: com.widevine.alpha`);
+                        });
+                    });
+                    describe('with videoCapabilities only', () => {
+                        const videoOnlyConfigurations = [
+                            {
+                                videoCapabilities: [
+                                    {
+                                        contentType: 'video/mp4',
+                                    },
+                                ],
+                            },
+                        ];
+                        describe('when isTypeSupported() returns true', () => {
+                            beforeEach(() => {
+                                MockWebKitMediaKeys.isTypeSupported.and.returnValue(true);
+                            });
+                            it('returns system access object', async () => {
+                                const access = await webKitCommonEme.requestMediaKeySystemAccess(keySystem, videoOnlyConfigurations);
+                                expect(access).toBeInstanceOf(WebKitCommonMediaKeySystemAccess);
+                                expect(access.keySystem).toBe(keySystem);
+                            });
+                        });
+                        describe('when isTypeSupported() returns false', () => {
+                            beforeEach(() => {
+                                MockWebKitMediaKeys.isTypeSupported.and.returnValue(false);
+                            });
+                            it('throws DrmError', async () => {
+                                await expectAsync(webKitCommonEme.requestMediaKeySystemAccess(keySystem, videoOnlyConfigurations)).toBeRejectedWithError(DrmError);
+                            });
+                        });
+                    });
+                    describe('with both audioCapabilities and videoCapabilities', () => {
+                        const bothConfigurations = [
+                            {
+                                audioCapabilities: [
+                                    {
+                                        contentType: 'audio/mp4',
+                                    },
+                                ],
+                                videoCapabilities: [
+                                    {
+                                        contentType: 'video/mp4',
+                                    },
+                                ],
+                            },
+                        ];
+                        it('checks all capabilities', async () => {
+                            MockWebKitMediaKeys.isTypeSupported.and.returnValue(true);
+                            await webKitCommonEme.requestMediaKeySystemAccess(keySystem, bothConfigurations);
+                            expect(MockWebKitMediaKeys.isTypeSupported).toHaveBeenCalledWith(keySystem, 'audio/mp4');
+                        });
+                        it('succeeds when only videoCapabilities is supported', async () => {
+                            MockWebKitMediaKeys.isTypeSupported.and.callFake((_ks, contentType) => contentType === 'video/mp4');
+                            const access = await webKitCommonEme.requestMediaKeySystemAccess(keySystem, bothConfigurations);
+                            expect(access).toBeInstanceOf(WebKitCommonMediaKeySystemAccess);
+                        });
+                    });
+                });
+                describe('without configs', () => {
+                    it('throws DrmError', async () => {
+                        await expectAsync(webKitCommonEme.requestMediaKeySystemAccess(keySystem, [])).toBeRejectedWithError(DrmError);
+                    });
+                });
+            });
+        });
+        describe('addEncryptedListener', () => {
+            it('adds a listener and returns an Unsubscribe handle', () => {
+                expect(mockAudioElementEventFakes.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+                const handler = jasmine.createSpy('handler');
+                const encryptedSub = webKitCommonEme.addEncryptedListener(mockAudioElement, handler);
+                expect(handler).not.toHaveBeenCalled();
+                expectTypeEquals(true);
+                const encryptedEvent = mockEvent('webkitneedkey');
+                mockAudioElement.dispatchEvent(encryptedEvent);
+                expect(handler).toHaveBeenCalledOnceWith(encryptedEvent);
+                encryptedSub();
+                expect(mockAudioElementEventFakes.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+            });
+        });
+    });
+    describe('WebKitCommonMediaKeySystemAccess', () => {
+        const keySystem = DrmKeySystem.WIDEVINE;
+        let webKitCommonMediaKeySystemAccess;
+        beforeEach(() => {
+            webKitCommonMediaKeySystemAccess =
+                new WebKitCommonMediaKeySystemAccess(keySystem);
+        });
+        it('creates media keys', async () => {
+            const mediaKeys = await webKitCommonMediaKeySystemAccess.createMediaKeys();
+            expect(mediaKeys)
+                .withContext('mediaKeys instanceof WebKitCommonMediaKeys')
+                .toBeInstanceOf(WebKitCommonMediaKeys);
+            expect(mediaKeys.keySystem).toBe(keySystem);
+        });
+    });
+    describe('WebKitCommonMediaKeys', () => {
+        let mockAudioElement;
+        let mockWebKitMediaKeys;
+        let webKitCommonMediaKeys;
+        beforeEach(() => {
+            mockAudioElement = new MockHTMLAudioElement();
+            mockAudioElement.webkitSetMediaKeys =
+                createSpy('webkitSetMediaKeys');
+            mockWebKitMediaKeys = new MockWebKitMediaKeys(DrmKeySystem.WIDEVINE);
+            webKitCommonMediaKeys = new WebKitCommonMediaKeys(DrmKeySystem.WIDEVINE, mockWebKitMediaKeys);
+            mockWebKitMediaKeys.createSession.and.callFake(() => {
+                return new MockWebKitMediaKeySession();
+            });
+        });
+        describe('setOnElement', () => {
+            it('sets media keys on element', async () => {
+                await webKitCommonMediaKeys.setOnElement(mockAudioElement);
+                expect(mockAudioElement.webkitSetMediaKeys).toHaveBeenCalledOnceWith(mockWebKitMediaKeys);
+            });
+        });
+        describe('clearFromElement', () => {
+            it('clears media keys on element', async () => {
+                await webKitCommonMediaKeys.clearFromElement(mockAudioElement);
+                expect(mockAudioElement.webkitSetMediaKeys).toHaveBeenCalledOnceWith(null);
+            });
+        });
+        describe('setServerCertificate', () => {
+            it('resolves to false', async () => {
+                await expectAsync(webKitCommonMediaKeys.setServerCertificate(new Uint8Array([1, 2, 3]))).toBeResolvedTo(false);
+            });
+        });
+        describe('createSession', () => {
+            const mimeType = 'mime';
+            const uint16Array = utf16ToUint16Array('skd://example0');
+            const uint8Array = new Uint8Array(uint16Array.buffer);
+            it('creates session', () => {
+                const session = webKitCommonMediaKeys.createSession(mimeType, 'cenc', uint8Array);
+                expect(mockWebKitMediaKeys.createSession).toHaveBeenCalledTimes(1);
+                expect(session).toBeInstanceOf(WebKitCommonMediaKeySession);
+            });
+        });
+    });
+    describe('WebKitCommonMediaKeySession', () => {
+        let mockWebKitMediaKeySession;
+        let mockWebKitMediaKeySessionEventFakes;
+        let webKitCommonMediaKeySession;
+        let mockWebKitMediaKeyError;
+        const mimeType = 'audio';
+        const initDataType = 'cenc';
+        const initData = new Uint8Array([1, 2, 3]);
+        beforeEach(() => {
+            mockWebKitMediaKeySession = new MockWebKitMediaKeySession();
+            mockWebKitMediaKeySessionEventFakes = implementEventFakes(mockWebKitMediaKeySession);
+            webKitCommonMediaKeySession = new WebKitCommonMediaKeySession(mockWebKitMediaKeySession, mimeType, initDataType, initData);
+            mockWebKitMediaKeyError = new MockWebKitMediaKeyError();
+        });
+        it('adds event listener on session for webkitkeymessage event', () => {
+            expect(mockWebKitMediaKeySession.addEventListener).toHaveBeenCalled();
+            const messageEventSpy = createEventSpy(webKitCommonMediaKeySession, 'message');
+            const messageEvent = new MockWebKitMediaKeyMessageEvent();
+            mockWebKitMediaKeySession.dispatchEvent(messageEvent);
+            expect(messageEventSpy).toHaveBeenCalledOnceWith({
+                message: messageEvent.message.buffer,
+            });
+        });
+        describe('when an event listener is added for webkitkeyerror event', () => {
+            describe('when session has error', () => {
+                beforeEach(() => {
+                    mockWebKitMediaKeySession.error =
+                        new MockWebKitMediaKeyError();
+                });
+                afterEach(() => {
+                    mockWebKitMediaKeySession.error = null;
+                });
+                it('emits event', () => {
+                    expect(mockWebKitMediaKeySession.addEventListener).toHaveBeenCalled();
+                    const messageEventSpy = createEventSpy(webKitCommonMediaKeySession, 'error');
+                    mockWebKitMediaKeySession.dispatchEvent(mockWebKitMediaKeyError);
+                    expect(messageEventSpy).toHaveBeenCalled();
+                });
+            });
+            describe('when session has no error', () => {
+                it("doesn't emit event", () => {
+                    const mockWebKitSession = new MockWebKitMediaKeySession();
+                    implementEventFakes(mockWebKitSession);
+                    const webkitCommonMediaKeySession = new WebKitCommonMediaKeySession(mockWebKitSession, mimeType, initDataType, initData);
+                    expect(mockWebKitSession.addEventListener).toHaveBeenCalled();
+                    const messageEventSpy = createEventSpy(webkitCommonMediaKeySession, 'error');
+                    mockWebKitSession.dispatchEvent(mockWebKitMediaKeyError);
+                    expect(messageEventSpy).not.toHaveBeenCalled();
+                });
+            });
+        });
+        describe('update', () => {
+            it('rejects update when disposed', async () => {
+                webKitCommonMediaKeySession.dispose();
+                await expectAsync(webKitCommonMediaKeySession.update(new ArrayBuffer(0))).toBeRejectedWith(new DisposedError());
+            });
+            it('updates media key session', async () => {
+                const arrayBuffer = new ArrayBuffer(0);
+                await webKitCommonMediaKeySession.update(arrayBuffer);
+                expect(mockWebKitMediaKeySession.update).toHaveBeenCalledOnceWith(new Uint8Array(arrayBuffer));
+            });
+        });
+        describe('dispose', () => {
+            it('removes listeners and closes session', () => {
+                expect(webKitCommonMediaKeySession.disposed).toBeFalse();
+                webKitCommonMediaKeySession.dispose();
+                expect(webKitCommonMediaKeySession.disposed).toBeTrue();
+                expect(mockWebKitMediaKeySessionEventFakes.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+                expect(mockWebKitMediaKeySession.close).toHaveBeenCalledOnceWith();
+            });
+        });
+    });
+    describe('webkitErrorCodeToStr', () => {
+        it('translates value correctly', () => {
+            expect(webkitErrorCodeToStr(WebKitMediaKeyError.MEDIA_KEYERR_CLIENT)).toBe(MediaKeySessionErrorType.CLIENT);
+            expect(webkitErrorCodeToStr(WebKitMediaKeyError.MEDIA_KEYERR_DOMAIN)).toBe(MediaKeySessionErrorType.DOMAIN);
+            expect(webkitErrorCodeToStr(WebKitMediaKeyError.MEDIA_KEYERR_HARDWARECHANGE)).toBe(MediaKeySessionErrorType.HARDWARECHANGE);
+            expect(webkitErrorCodeToStr(WebKitMediaKeyError.MEDIA_KEYERR_OUTPUT)).toBe(MediaKeySessionErrorType.OUTPUT);
+            expect(webkitErrorCodeToStr(WebKitMediaKeyError.MEDIA_KEYERR_SERVICE)).toBe(MediaKeySessionErrorType.SERVICE);
+            expect(webkitErrorCodeToStr(WebKitMediaKeyError.MEDIA_KEYERR_UNKNOWN)).toBe(MediaKeySessionErrorType.UNKNOWN);
+        });
+    });
+});

package/dist/unit/types/current/drm/commonEme/createDrmErrorHandler.test.d.ts

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

package/dist/unit/types/current/drm/commonEme/createDrmErrorHandler.test.d.ts.map

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

package/dist/unit/types/current/drm/commonEme/createDrmErrorHandler.test.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDrmErrorHandler, DrmError } from '@amazon/vinyl';
+import { ErrorLevel } from '@amazon/vinyl-util';
+var objectContaining = jasmine.objectContaining;
+describe('createDrmErrorHandler', () => {
+    it('returns a function to wrap a provided Error object in a DrmError', () => {
+        const handler = createDrmErrorHandler();
+        expect(() => handler(new Error('expected'))).toThrowError(DrmError, 'expected');
+        expect(() => handler(new Error('expected'))).toThrowMatching((drmError) => {
+            expect(drmError.toJSON()).toEqual(objectContaining({
+                extra: {
+                    error: objectContaining({
+                        message: 'expected',
+                    }),
+                },
+            }));
+            return drmError.level === ErrorLevel.FATAL;
+        });
+    });
+});

package/dist/unit/types/current/drm/error/DrmError.test.d.ts

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

package/dist/unit/types/current/drm/error/DrmError.test.d.ts.map

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

package/dist/unit/types/current/drm/error/DrmError.test.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DrmError } from '@amazon/vinyl';
+import { ErrorLevel, ErrorOrigin, ReportableError } from '@amazon/vinyl-util';
+import { expectPrototype } from '@amazon/vinyl-util/browserTestUtil';
+var objectContaining = jasmine.objectContaining;
+var any = jasmine.any;
+describe('DrmError', () => {
+    it('is an instance of Error and DrmError', () => {
+        expectPrototype(() => new DrmError(''), DrmError, ReportableError, Error);
+    });
+    it('is fatal by default', () => {
+        expect(new DrmError('').level).toBe(ErrorLevel.FATAL);
+        expect(new DrmError('', {}, ErrorOrigin.UNCAUGHT, ErrorLevel.WARN).level).toBe(ErrorLevel.WARN);
+    });
+    describe('toStringTag', () => {
+        it('returns the name', () => {
+            expect(new DrmError('')[Symbol.toStringTag]).toBe('DrmError');
+        });
+    });
+    describe('toJSON', () => {
+        it('provides a serializable representation', () => {
+            expect(new DrmError('message', { keySystem: 'myKeySystem' }, ErrorOrigin.DRM, ErrorLevel.SILENT).toJSON()).toEqual(objectContaining({
+                message: 'message',
+                extra: { keySystem: 'myKeySystem' },
+                stack: any(String),
+                origin: ErrorOrigin.DRM,
+                level: ErrorLevel.SILENT,
+            }));
+        });
+    });
+});

package/dist/unit/types/current/drm/licenseProvider/defaultLicenseProvider.test.d.ts

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

package/dist/unit/types/current/drm/licenseProvider/defaultLicenseProvider.test.d.ts.map

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

package/dist/unit/types/current/drm/licenseProvider/defaultLicenseProvider.test.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { defaultLicenseProvider, DrmKeySystem } from '@amazon/vinyl';
+import { Abort, requesterWithRetryRef, ValidationError, } from '@amazon/vinyl-util';
+import { MockRequester, overrideGlobalInit } from '@amazon/vinyl-util/testUtil';
+var any = jasmine.any;
+var objectContaining = jasmine.objectContaining;
+describe('defaultLicenseProvider', () => {
+    describe('when serverOptions url is undefined', () => {
+        it('rejects with a ValidationError', async () => {
+            await expectAsync(defaultLicenseProvider(DrmKeySystem.WIDEVINE, {}, new ArrayBuffer(0))).toBeRejectedWithError(ValidationError, 'Missing licenseServer url in DRM configuration for keySystem: com.widevine.alpha');
+        });
+    });
+    describe('when provided a license server url', () => {
+        const requesterOverride = overrideGlobalInit(requesterWithRetryRef, () => new MockRequester());
+        let requestSpy;
+        beforeEach(() => {
+            requestSpy = requesterOverride.value.request;
+        });
+        it('performs a request with the url, init options, and challenge', async () => {
+            const arrayBuffer = new ArrayBuffer(0);
+            const mockResponse = new Response(arrayBuffer);
+            requestSpy.and.returnValue(Promise.resolve(mockResponse));
+            const challenge = new ArrayBuffer(0);
+            await expectAsync(defaultLicenseProvider(DrmKeySystem.WIDEVINE, {
+                url: 'https://example.com',
+                init: { headers: { foo: 'bar' } },
+            }, challenge, new Abort())).toBeResolvedTo(arrayBuffer);
+            expect(requestSpy).toHaveBeenCalledOnceWith('https://example.com', objectContaining({
+                headers: {
+                    foo: 'bar',
+                },
+                body: challenge,
+                method: 'POST',
+            }), objectContaining({
+                abort: any(Abort),
+            }));
+        });
+    });
+});

package/dist/unit/types/current/drm/util/createFairPlaySessionInitData.test.d.ts

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

package/dist/unit/types/current/drm/util/createFairPlaySessionInitData.test.d.ts.map

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

package/dist/unit/types/current/drm/util/createFairPlaySessionInitData.test.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createFairPlaySessionInitData } from '@amazon/vinyl';
+import { base64ToByteArray } from '@amazon/vinyl-util';
+describe('createFairPlaySessionInitData', () => {
+    it('returns correctly formed Uint8Array', () => {
+        // These data were extracted from a catalog track, asin://B0B5HKZZ98.
+        const initData = 'VAAAAHMAawBkADoALwAvADAAYgA1ADYAOAA5AGIAYgAtADQAMQA3ADEALQA5ADcAZQA1AC0AYwAyADgAMAAtADkAOQBmADcAYQBiAGUANAAwADAANABmAA==';
+        const contentId = '0b5689bb-4171-97e5-c280-99f7abe4004f';
+        const certificateData = 'MIIE1TCCA72gAwIBAgIIFW3qWt9NdaQwDQYJKoZIhvcNAQEFBQAwfzELMAkGA1UEBhMCVVMxEzARBgNVBAoMCkFwcGxlIEluYy4xJjAkBgNVBAsMHUFwcGxlIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MTMwMQYDVQQDDCpBcHBsZSBLZXkgU2VydmljZXMgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTQwODI3MTcwMjI3WhcNMTYwODI3MTcwMjI3WjBuMQswCQYDVQQGEwJVUzETMBEGA1UECgwKQW1hem9uLmNvbTEWMBQGA1UECwwNRGlnaXRhbCBWaWRlbzEyMDAGA1UEAwwpRlBTIGZvciBBbWF6b24gSW5zdGFudCBWaWRlbyBhcHBsaWNhdGlvbnMwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAKTLDDVOTIYAGQO0nwblswQ3jjz4sc9tD7dYdxTgaAekFadAJdcsiOwCtudDLunhE3q4uNMQtAh4UExvzL9pUxhnzyeuAmHOTI8vUCCcVD2mt03w98EUFXpUU82s5EauWX8rrUI07FCdWdnD3ylj/eIVdbbQhKcvkvoipiCO4fedAgMBAAGjggHoMIIB5DAdBgNVHQ4EFgQUW+PdiCeqmpoNPwdJIng5MA465MYwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRj5EdUy4VxWUYsg6zMRDFkZwMsvjCB4gYDVR0gBIHaMIHXMIHUBgkqhkiG92NkBQEwgcYwgcMGCCsGAQUFBwICMIG2DIGzUmVsaWFuY2Ugb24gdGhpcyBjZXJ0aWZpY2F0ZSBieSBhbnkgcGFydHkgYXNzdW1lcyBhY2NlcHRhbmNlIG9mIHRoZSB0aGVuIGFwcGxpY2FibGUgc3RhbmRhcmQgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdXNlLCBjZXJ0aWZpY2F0ZSBwb2xpY3kgYW5kIGNlcnRpZmljYXRpb24gcHJhY3RpY2Ugc3RhdGVtZW50cy4wNQYDVR0fBC4wLDAqoCigJoYkaHR0cDovL2NybC5hcHBsZS5jb20va2V5c2VydmljZXMuY3JsMA4GA1UdDwEB/wQEAwIFIDAuBgsqhkiG92NkBg0BAwEB/wQcAXA1O2DFgVbri+9ptKoYMZ/p8CQpC6dMjuxHqzA4BgsqhkiG92NkBg0BBAEB/wQmASf94c8MkzPOIrjZGeyjlFaiDcQlWfRzqMe/ZMSbmtmEEWv/xP4wDQYJKoZIhvcNAQEFBQADggEBAIKRz+hZDC2v99OCaqJY/6+L1EUJscv2hP6MC5yKSte0rkwuJUYIFbzBUlmyq39Osli5ma+5afrCgTy0Rtw3QVPeZDI47zWfBVNQrgwh+eQ9Gg1pGM6V5MXP4SVsC6MkuygPfQr4fz0WDewfBBU6V13LZr7Y0jZ2AMmrit5W+i11uvL/6oKtA6AYsdX/MWt+IgBkt2prRwxf2S2w0rp41Azzg1a7lXeTqJ5uI22NkjmsjLw0PjnjOKyc0FR96iHW2VbCa+ev1fejVcCJolgVEPd/rZNrRomKvfkEjy1hbVtoxc2W9ndvLt7fU6I5MRCFIWGEHQfK5iYyZLuaX5CmGxg=';
+        const result = 'VAAAAHMAawBkADoALwAvADAAYgA1ADYAOAA5AGIAYgAtADQAMQA3ADEALQA5ADcAZQA1AC0AYwAyADgAMAAtADkAOQBmADcAYQBiAGUANAAwADAANABmAEgAAAAwAGIANQA2ADgAOQBiAGIALQA0ADEANwAxAC0AOQA3AGUANQAtAGMAMgA4ADAALQA5ADkAZgA3AGEAYgBlADQAMAAwADQAZgDZBAAAMIIE1TCCA72gAwIBAgIIFW3qWt9NdaQwDQYJKoZIhvcNAQEFBQAwfzELMAkGA1UEBhMCVVMxEzARBgNVBAoMCkFwcGxlIEluYy4xJjAkBgNVBAsMHUFwcGxlIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MTMwMQYDVQQDDCpBcHBsZSBLZXkgU2VydmljZXMgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTQwODI3MTcwMjI3WhcNMTYwODI3MTcwMjI3WjBuMQswCQYDVQQGEwJVUzETMBEGA1UECgwKQW1hem9uLmNvbTEWMBQGA1UECwwNRGlnaXRhbCBWaWRlbzEyMDAGA1UEAwwpRlBTIGZvciBBbWF6b24gSW5zdGFudCBWaWRlbyBhcHBsaWNhdGlvbnMwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAKTLDDVOTIYAGQO0nwblswQ3jjz4sc9tD7dYdxTgaAekFadAJdcsiOwCtudDLunhE3q4uNMQtAh4UExvzL9pUxhnzyeuAmHOTI8vUCCcVD2mt03w98EUFXpUU82s5EauWX8rrUI07FCdWdnD3ylj/eIVdbbQhKcvkvoipiCO4fedAgMBAAGjggHoMIIB5DAdBgNVHQ4EFgQUW+PdiCeqmpoNPwdJIng5MA465MYwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRj5EdUy4VxWUYsg6zMRDFkZwMsvjCB4gYDVR0gBIHaMIHXMIHUBgkqhkiG92NkBQEwgcYwgcMGCCsGAQUFBwICMIG2DIGzUmVsaWFuY2Ugb24gdGhpcyBjZXJ0aWZpY2F0ZSBieSBhbnkgcGFydHkgYXNzdW1lcyBhY2NlcHRhbmNlIG9mIHRoZSB0aGVuIGFwcGxpY2FibGUgc3RhbmRhcmQgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdXNlLCBjZXJ0aWZpY2F0ZSBwb2xpY3kgYW5kIGNlcnRpZmljYXRpb24gcHJhY3RpY2Ugc3RhdGVtZW50cy4wNQYDVR0fBC4wLDAqoCigJoYkaHR0cDovL2NybC5hcHBsZS5jb20va2V5c2VydmljZXMuY3JsMA4GA1UdDwEB/wQEAwIFIDAuBgsqhkiG92NkBg0BAwEB/wQcAXA1O2DFgVbri+9ptKoYMZ/p8CQpC6dMjuxHqzA4BgsqhkiG92NkBg0BBAEB/wQmASf94c8MkzPOIrjZGeyjlFaiDcQlWfRzqMe/ZMSbmtmEEWv/xP4wDQYJKoZIhvcNAQEFBQADggEBAIKRz+hZDC2v99OCaqJY/6+L1EUJscv2hP6MC5yKSte0rkwuJUYIFbzBUlmyq39Osli5ma+5afrCgTy0Rtw3QVPeZDI47zWfBVNQrgwh+eQ9Gg1pGM6V5MXP4SVsC6MkuygPfQr4fz0WDewfBBU6V13LZr7Y0jZ2AMmrit5W+i11uvL/6oKtA6AYsdX/MWt+IgBkt2prRwxf2S2w0rp41Azzg1a7lXeTqJ5uI22NkjmsjLw0PjnjOKyc0FR96iHW2VbCa+ev1fejVcCJolgVEPd/rZNrRomKvfkEjy1hbVtoxc2W9ndvLt7fU6I5MRCFIWGEHQfK5iYyZLuaX5CmGxg=';
+        expect(createFairPlaySessionInitData(base64ToByteArray(initData), contentId, base64ToByteArray(certificateData))).toEqual(base64ToByteArray(result));
+    });
+});

package/dist/unit/types/current/drm/util/extractContentId.test.d.ts

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

package/dist/unit/types/current/drm/util/extractContentId.test.d.ts.map

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

package/dist/unit/types/current/drm/util/extractContentId.test.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { extractContentId } from '@amazon/vinyl';
+import { utf16ToUint16Array, ValidationError } from '@amazon/vinyl-util';
+describe('extractContentId', () => {
+    function createContentIdByteArray(str) {
+        const uint16Array = utf16ToUint16Array(str);
+        return new Uint8Array(uint16Array.buffer);
+    }
+    describe('with match', () => {
+        it('matches', () => {
+            expect(extractContentId(createContentIdByteArray('skd://example0'))).toBe('example0');
+        });
+    });
+    describe('without match', () => {
+        it('throws ValidationError', () => {
+            expect(() => {
+                extractContentId(new Uint8Array());
+            }).toThrowError(ValidationError, 'No contentId match');
+            expect(() => {
+                expect(extractContentId(createContentIdByteArray('skd://'))).toBe('example0');
+            }).toThrowError(ValidationError, 'No contentId match');
+        });
+    });
+});

package/dist/unit/types/current/drm/util/unpackPlayReadyChallenge.test.d.ts

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

package/dist/unit/types/current/drm/util/unpackPlayReadyChallenge.test.d.ts.map

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

package/dist/unit/types/current/drm/util/unpackPlayReadyChallenge.test.js

@@ -0,0 +1,104 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { parsePlayReadyKeyMessage, unpackPlayReadyChallenge, } from '@amazon/vinyl';
+import { bufferToBase64, utf16ToUint16Array } from '@amazon/vinyl-util';
+describe('unpackPlayReadyChallenge', () => {
+    describe('when the challenge is not packed', () => {
+        it('returns the challenge as is and returns a content type header', () => {
+            {
+                const challenge = new Uint8Array([1, 2, 3, 4]).buffer;
+                expect(unpackPlayReadyChallenge(challenge)).toEqual({
+                    challenge,
+                    headers: {
+                        'Content-Type': 'text/xml; charset=utf-8',
+                    },
+                });
+            }
+            {
+                const challenge = new Uint8Array([1, 2, 3]).buffer; // Odd length challenges cannot be UTF-16
+                expect(unpackPlayReadyChallenge(challenge)).toEqual({
+                    challenge,
+                    headers: {
+                        'Content-Type': 'text/xml; charset=utf-8',
+                    },
+                });
+            }
+        });
+    });
+    describe('when the challenge is packed', () => {
+        it('returns the unpacked challenge with parsed headers', () => {
+            const challenge = new Uint8Array([1, 2, 3, 4, 5, 6]).buffer;
+            const xml = `<PlayReadyKeyMessage type="LicenseAcquisition">
+       <LicenseAcquisition Version="1">
+         <Challenge encoding="base64encoded">${bufferToBase64(challenge)}</Challenge>
+         <HttpHeaders>
+           <HttpHeader>
+             <name>Content-Type</name>
+             <value>text/xml; charset=utf-8</value>
+           </HttpHeader>
+           <HttpHeader>
+             <name>SOAPAction</name>
+             <value>http://schemas.microsoft.com/DRM/etc/etc</value>
+           </HttpHeader>
+         </HttpHeaders>
+       </LicenseAcquisition>
+     </PlayReadyKeyMessage>`;
+            expect(unpackPlayReadyChallenge(utf16ToUint16Array(xml))).toEqual({
+                headers: {
+                    'Content-Type': 'text/xml; charset=utf-8',
+                    SOAPAction: 'http://schemas.microsoft.com/DRM/etc/etc',
+                },
+                challenge: challenge,
+            });
+        });
+    });
+});
+describe('parsePlayReadyKeyMessage', () => {
+    it('returns a parsed PlayReadyKeyMessage', () => {
+        // language=XML
+        const message = parsePlayReadyKeyMessage(`<PlayReadyKeyMessage type="LicenseAcquisition">
+       <LicenseAcquisition Version="1">
+         <Challenge encoding="base64encoded">aabbccdd</Challenge>
+         <HttpHeaders>
+           <HttpHeader>
+             <name>Content-Type</name>
+             <value>text/xml; charset=utf-8</value>
+           </HttpHeader>
+           <HttpHeader>
+             <name>SOAPAction</name>
+             <value>http://schemas.microsoft.com/DRM/etc/etc</value>
+           </HttpHeader>
+         </HttpHeaders>
+       </LicenseAcquisition>
+     </PlayReadyKeyMessage>
+        `);
+        expect(message.toJSON()).toEqual({
+            PlayReadyKeyMessage: {
+                type: 'LicenseAcquisition',
+                LicenseAcquisition: {
+                    Version: 1,
+                    Challenge: {
+                        encoding: 'base64encoded',
+                        _content: 'aabbccdd',
+                    },
+                    HttpHeaders: {
+                        HttpHeader: [
+                            {
+                                name: { _content: 'Content-Type' },
+                                value: { _content: 'text/xml; charset=utf-8' },
+                            },
+                            {
+                                name: { _content: 'SOAPAction' },
+                                value: {
+                                    _content: 'http://schemas.microsoft.com/DRM/etc/etc',
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        });
+    });
+});

package/dist/unit/types/current/event/ChangeEvent.test.d.ts

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

package/dist/unit/types/current/event/ChangeEvent.test.d.ts.map

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

package/dist/unit/types/current/event/ChangeEvent.test.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var createSpy = jasmine.createSpy;
+import { createChangeEventTrigger } from '@amazon/vinyl';
+describe('createChangeEventTr' + 'igger', () => {
+    it('returns a function that calls an inner function with a change event', () => {
+        const o = { value: 1 };
+        const spy = createSpy('valueChanged');
+        const trigger = createChangeEventTrigger(() => o.value, spy);
+        expect(spy).not.toHaveBeenCalled();
+        o.value = 2;
+        trigger();
+        expect(spy).toHaveBeenCalledOnceWith({ previous: 1, current: 2 });
+        spy.calls.reset();
+        o.value = 3;
+        trigger();
+        expect(spy).toHaveBeenCalledOnceWith({ previous: 2, current: 3 });
+    });
+});

package/dist/unit/types/current/global/PlayerRegistry.test.d.ts

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

package/dist/unit/types/current/global/PlayerRegistry.test.d.ts.map

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