@amazon/vinyl 1.0.0

package/dist/types/current/drm/DrmControllerImpl.js

@@ -0,0 +1,469 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AbortError, base64ToByteArray, buffersEqual, bufferToByteArray, clone, compareBy, createDisposer, ErrorOrigin, EventHostImpl, isSilentError, logDebug, logVerbose, memoize, noop, normalizeHeadersInit, remove, resolveValueProvider, withTimeout, } from '@amazon/vinyl-util';
+import { instanceOf, object } from '@amazon/vinyl-validation';
+import { DrmRobustness, } from '../drm/DrmOptions';
+import { DrmError } from '../drm/error/DrmError';
+import { DrmKeySystem, isPlayReady } from '../drm/DrmKeySystem';
+import { unpackPlayReadyChallenge } from '../drm/util/unpackPlayReadyChallenge';
+import { defaultLicenseProvider } from '../drm/licenseProvider/defaultLicenseProvider';
+import { extractContentId } from '../drm/util/extractContentId';
+import { createFairPlaySessionInitData } from '../drm/util/createFairPlaySessionInitData';
+/**
+ * The number of seconds a license request will be allowed before timing out.
+ * This should be higher than the network timeout.
+ *
+ * In practice, network requests will time out before this, and a license timeout
+ * indicates a stalled promise result from the license provider.
+ */
+export const LICENSE_TIMEOUT = 90;
+const LICENSE_TIMEOUT_MESSAGE = 'License provider timed out after {time}s';
+export class DrmControllerImpl extends EventHostImpl {
+    deps;
+    get [Symbol.toStringTag]() {
+        return 'DrmControllerImpl';
+    }
+    optionsBase;
+    options;
+    mediaKeys = null;
+    mediaKeysPromise = null;
+    sessions = [];
+    _error = null;
+    drmInfo = null;
+    sessionAbort = null;
+    pendingMessageProps = null;
+    disposer = createDisposer();
+    constructor(deps, options) {
+        super();
+        this.deps = deps;
+        this.optionsBase = { keySystems: {}, ...options };
+        this.options = this.optionsBase;
+        if (this.deps.commonEme) {
+            this.disposer.add(this.deps.commonEme.addEncryptedListener(this.deps.media, this.handleEncryptedEvent));
+        }
+    }
+    configure(options) {
+        this.options = {
+            ...this.optionsBase,
+            ...options,
+            keySystems: {
+                ...this.optionsBase.keySystems,
+                ...options?.keySystems,
+            },
+        };
+    }
+    get licenseProvider() {
+        return this.options.licenseProvider ?? defaultLicenseProvider;
+    }
+    get error() {
+        return this._error;
+    }
+    isEmeSupported() {
+        return this.deps.commonEme != null;
+    }
+    async isSupported(drmInfo) {
+        const accessParamsList = this.createMediaKeySystemAccessParams(drmInfo);
+        for (const params of accessParamsList) {
+            const result = await this.checkIsSupportedCached(params);
+            if (result.supported)
+                return result;
+        }
+        return { supported: false, persistentState: false };
+    }
+    checkIsSupportedCached = memoize(async (params) => {
+        try {
+            await this.deps.commonEme.requestMediaKeySystemAccess(params.keySystem, [params.config]);
+            logVerbose(this, 'requestMediaKeySystemAccess supported', params);
+            return {
+                supported: true,
+                persistentState: params.config.persistentState === 'required',
+            };
+        }
+        catch (_) {
+            logVerbose(this, 'requestMediaKeySystemAccess rejected', params);
+            return { supported: false, persistentState: false };
+        }
+    }, (options) => options.cacheKey, 20 // capacity
+    );
+    handleEncryptedEvent = (event) => {
+        if (this.disposed)
+            return;
+        (async () => {
+            const { initData, initDataType } = event;
+            if (!initData) {
+                // https://www.w3.org/TR/2014/WD-encrypted-media-20140218/#dom-mediakeyneededevent
+                // https://www.w3.org/TR/encrypted-media/#initialization-data
+                // Initialization data could not be obtained, possibly due to cross-origin policy issues.
+                throw new DrmError('encrypted event provided null initData. Check CORS policies.');
+            }
+            logDebug(this, `encrypted, initDataType: ${initDataType}, initData.byteLength: ${initData.byteLength}`);
+            if (!this.drmInfo?.contentProtections.length) {
+                throw new DrmError('Encrypted content not configured with content protections.');
+            }
+            await this.maybeCreateSession(this.drmInfo, initDataType, initData, this.sessionAbort);
+        })().catch(this.handleError);
+    };
+    /**
+     * Resolves to media keys attached to the element.
+     * The media keys will only be created and set once until `clearMediaKeys` is next called.
+     */
+    async attachMediaKeys(drmInfo) {
+        if (!this.mediaKeysPromise) {
+            this.mediaKeysPromise = (async () => {
+                logDebug(this, 'creating media keys');
+                const access = await this.createAccess(drmInfo);
+                const mediaKeys = await access.createMediaKeys();
+                this.abortIfDisposed();
+                this.mediaKeys = mediaKeys;
+                await mediaKeys.setOnElement(this.deps.media);
+                logDebug(this, `set media keys on element`);
+                this.dispatch('mediaKeysSet', {
+                    keySystem: mediaKeys.keySystem,
+                });
+                return mediaKeys;
+            })();
+        }
+        return this.mediaKeysPromise;
+    }
+    /**
+     * Creates a session for the given initialization data if none currently exists.
+     * This will be done either after an 'encrypted' event or when drm metadata contains initialization data.
+     * The new session will be added to the current sessions list.
+     */
+    async maybeCreateSession(drmInfo, initDataType, initData, abort) {
+        if (!hasMimeType(drmInfo)) {
+            throw new DrmError('Encrypted content must have a mimeType.');
+        }
+        const mediaKeys = await this.attachMediaKeys(drmInfo);
+        this.abortIfDisposed();
+        // Resolve server certificate from configuration
+        const keySystemOptions = this.options.keySystems[mediaKeys.keySystem] ??
+            this.options.keySystems['*'];
+        const licenseServerOptionsProvider = keySystemOptions?.licenseServer;
+        const licenseServerOptions = await resolveValueProvider(licenseServerOptionsProvider ?? {});
+        this.abortIfDisposed();
+        const existingSession = this.getSessionByInitData(initData);
+        if (existingSession) {
+            logDebug(this, 'reusing session');
+            return existingSession;
+        }
+        else {
+            const newSession = await this.createNewSession(licenseServerOptions.serverCertificate, mediaKeys, initData, initDataType, drmInfo, keySystemOptions?.initDataTransformer);
+            this.sessions.push(newSession);
+            this.dispatch('sessionCreate', {
+                initDataType: newSession.initDataType,
+                mimeType: newSession.mimeType,
+            });
+            newSession.on('closed', () => this.closeSession(newSession));
+            abort?.onAborted(() => {
+                logDebug(this, 'abort session');
+                this.closeSession(newSession);
+            });
+            return newSession;
+        }
+    }
+    initializeForPlayback(drmInfo, abort) {
+        logDebug(this, 'initializeForPlayback', drmInfo);
+        if (drmInfo?.contentProtections.length) {
+            this.createSessionFromInitData(drmInfo, abort).catch(this.handleError);
+        }
+    }
+    setBufferingDrmInfo(drmInfo, abort) {
+        logDebug(this, 'setBufferingDrmInfo', drmInfo);
+        // Reset 'encrypted' error reporting
+        this.reset();
+        this.drmInfo = drmInfo;
+        this.sessionAbort = abort ?? null;
+    }
+    /**
+     * If the drm metadata contains initialization data for the current key system, create a new session.
+     * Otherwise, wait for the 'encrypted' event for the initialization data.
+     */
+    async createSessionFromInitData(drmInfo, abort) {
+        if (!this.deps.commonEme) {
+            this.handleError(new DrmError('DRM not supported.'));
+            return;
+        }
+        const mediaKeys = await this.attachMediaKeys(drmInfo);
+        const drmProtection = drmInfo.contentProtections.find((cP) => {
+            return cP.keySystem === mediaKeys.keySystem;
+        }) ?? null;
+        if (!drmProtection) {
+            // Media keys have been initialized, but content is not encrypted with the current keySystem.
+            throw new DrmError(`Encrypted content does not support set keySystem: '${mediaKeys.keySystem}'.`, { drmInfo });
+        }
+        if (drmProtection.pssh) {
+            await this.maybeCreateSession(drmInfo, drmInfo.initDataType ?? 'cenc', base64ToByteArray(drmProtection.pssh), abort);
+        }
+    }
+    /**
+     * Creates a CommonMediaKeySystemAccess object from the given content protection settings.
+     */
+    async createAccess(drmInfo) {
+        const accessParamsList = this.createMediaKeySystemAccessParams(drmInfo);
+        for (const { keySystem, config } of accessParamsList) {
+            try {
+                const access = await this.deps.commonEme.requestMediaKeySystemAccess(keySystem, [config]);
+                logDebug(this, `created media key system access for keySystem: ${access.keySystem}}`, config);
+                return access;
+            }
+            catch (_) {
+                // ignore
+            }
+        }
+        throw new DrmError(`No keySystem supported`, {
+            contentProtections: drmInfo,
+            attemptedKeySystems: accessParamsList.map((arr) => arr.keySystem),
+        }, ErrorOrigin.DRM);
+    }
+    /**
+     * Creates a list of the MediaKeySystemAccess configurations to try for the given media format options.
+     */
+    createMediaKeySystemAccessParams(drmInfo) {
+        const keySystems = drmInfo.contentProtections
+            .map((protection) => protection.keySystem)
+            .sort(this.keySystemComparator);
+        return keySystems.map((keySystem) => {
+            const mediaOptions = this.getMediaKeySystemOptions(keySystem, drmInfo.contentType);
+            const capability = {
+                robustness: mediaOptions?.robustness ?? DrmRobustness.SW_SECURE_CRYPTO,
+                encryptionScheme: drmInfo.encryptionScheme,
+            };
+            if (drmInfo.mimeType) {
+                capability.contentType = drmInfo.mimeType;
+            }
+            const config = {
+                initDataTypes: [drmInfo.initDataType ?? 'cenc'],
+            };
+            const contentType = drmInfo.contentType;
+            if (contentType === 'video') {
+                config.videoCapabilities = [capability];
+            }
+            else if (contentType === 'audio') {
+                config.audioCapabilities = [capability];
+            }
+            return {
+                keySystem,
+                config,
+                // Concatenate a list of inputs to use as a cache key for isSupported checks.
+                cacheKey: [
+                    keySystem,
+                    drmInfo.mimeType,
+                    drmInfo.contentType,
+                    capability.robustness,
+                    drmInfo.encryptionScheme,
+                    drmInfo.initDataType,
+                ]
+                    .map(String)
+                    .join('|'),
+            };
+        });
+    }
+    getMediaKeySystemOptions(keySystem, contentType) {
+        const keySystems = this.options.keySystems;
+        const keySystemOptions = keySystems[keySystem] ?? keySystems['*'];
+        if (!keySystemOptions)
+            return undefined;
+        switch (contentType) {
+            case 'video':
+                return keySystemOptions.video;
+            case 'audio':
+                return keySystemOptions.audio;
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Creates a new key session and adds a message handler.
+     */
+    async createNewSession(serverCertificate, mediaKeys, initData, initDataType, drmInfo, initDataTransformer) {
+        const certBytes = serverCertificate
+            ? typeof serverCertificate === 'string'
+                ? base64ToByteArray(serverCertificate)
+                : bufferToByteArray(serverCertificate)
+            : null;
+        if (certBytes) {
+            await mediaKeys.setServerCertificate(certBytes);
+        }
+        // Default initDataTransformer handles FAIR_PLAY_1_0 by packing the
+        // skd init data with the content ID and server certificate.
+        // FAIR_PLAY_1_0 always uses initDataType 'skd', so the default
+        // does not need to explicitly check initDataType.
+        const transform = initDataTransformer ??
+            defaultInitDataTransformer(mediaKeys.keySystem, certBytes);
+        initData = transform(bufferToByteArray(initData), initDataType, drmInfo);
+        logDebug(this, 'createSession', drmInfo.mimeType, initDataType);
+        const session = mediaKeys.createSession(drmInfo.mimeType, initDataType, initData);
+        session.on('message', (event) => {
+            withTimeout(this.messageHandler({
+                mediaKeys: mediaKeys,
+                session: session,
+                event: event,
+            }), LICENSE_TIMEOUT, LICENSE_TIMEOUT_MESSAGE).catch(this.handleError);
+        });
+        session.on('error', (event) => {
+            this.closeSession(session);
+            this.handleError(event.error);
+        });
+        return session;
+    }
+    /**
+     * Invoked when the content decryption module needs to interact with the license server.
+     */
+    async messageHandler(messageProps) {
+        const { mediaKeys, session, event } = messageProps;
+        messageEventValidator.assert(event);
+        this.pendingMessageProps = messageProps;
+        const keySystem = mediaKeys.keySystem;
+        logDebug(this, 'message', keySystem, event.message.byteLength);
+        const keySystemOptions = this.options.keySystems[keySystem];
+        const licenseServerOptionsProvider = keySystemOptions?.licenseServer;
+        // Get the license server configuration for the current key system.
+        const licenseServerOptions = clone(await resolveValueProvider(licenseServerOptionsProvider)) ??
+            {};
+        let challenge = event.message;
+        if (isPlayReady(keySystem)) {
+            const unpacked = unpackPlayReadyChallenge(challenge);
+            challenge = unpacked.challenge;
+            if (licenseServerOptions.init == null)
+                licenseServerOptions.init = {};
+            licenseServerOptions.init.headers = {
+                ...normalizeHeadersInit(licenseServerOptions.init.headers ?? {}),
+                ...unpacked.headers,
+            };
+        }
+        const key = await this.licenseProvider(keySystem, licenseServerOptions, challenge);
+        this.pendingMessageProps = null;
+        if (session.disposed)
+            return;
+        logDebug(this, 'update');
+        await session.update(key);
+    }
+    //--------------------------------------------
+    // Session management
+    //--------------------------------------------
+    /**
+     * Closes all active DRM sessions.
+     * This should not be called unless the audio source has been cleared.
+     */
+    closeSessions() {
+        logDebug(this, `clearing ${this.sessions.length} sessions`);
+        while (this.sessions.length)
+            this.closeSession(this.sessions[0]);
+    }
+    closeSession(session) {
+        logDebug(this, 'closeSession');
+        session.dispose();
+        remove(this.sessions, session);
+        this.dispatch('sessionClose', {
+            initDataType: session.initDataType,
+            mimeType: session.mimeType,
+        });
+    }
+    /**
+     * A handler which dispatches an error event.
+     * Only one error event will be emitted per unique PSSH.
+     * When track protections is set again, another error event may be emitted.
+     */
+    handleError = (error) => {
+        if (!this._error && !isSilentError(error)) {
+            this._error = error;
+            this.dispatch('error', { error, target: this });
+        }
+    };
+    /**
+     * Returns the number of currently active sessions.
+     */
+    get activeSessions() {
+        return this.sessions.length;
+    }
+    /**
+     * Clears the media keys from the element if they were set.
+     */
+    clearMediaKeys() {
+        this.closeSessions();
+        if (this.mediaKeys) {
+            logDebug(this, 'clearing media keys');
+            this.mediaKeys.clearFromElement(this.deps.media).catch(noop);
+            this.mediaKeys = null;
+        }
+        this.mediaKeysPromise = null;
+    }
+    abortIfDisposed() {
+        if (this.disposed)
+            throw new AbortError();
+    }
+    reset() {
+        if (!this._error) {
+            logDebug(this, 'reset no-op');
+            return;
+        }
+        logDebug(this, 'reset');
+        this._error = null;
+        if (this.pendingMessageProps) {
+            const mediaError = this.deps.media.error;
+            if (mediaError && mediaError.code === mediaError.MEDIA_ERR_DECODE) {
+                // Media is in a failed decoding state, cannot recover from a failed license request.
+                // The PlaybackController will attempt a reset.
+                logDebug(this, 'media in an error state, will not retry failed license challenge');
+                this.pendingMessageProps = null;
+            }
+            else {
+                logDebug(this, 'retrying failed license challenge');
+                this.messageHandler(this.pendingMessageProps).catch(this.handleError);
+            }
+        }
+        this.dispatch('reset', {});
+    }
+    get disposed() {
+        return this.disposer.disposed;
+    }
+    dispose() {
+        logDebug(this, 'dispose');
+        super.dispose();
+        this.clearMediaKeys();
+        this.disposer.dispose();
+    }
+    getSessionByInitData(initData) {
+        return (this.sessions.find((session) => {
+            return buffersEqual(session.initData, initData);
+        }) ?? null);
+    }
+    /**
+     * Sort the key systems first by their priority, then by the presence of a license uri.
+     */
+    keySystemComparator = compareBy((keySystem) => {
+        return -(this.options.keySystems[keySystem]?.priority ?? 0);
+    }, (keySystem) => {
+        return this.options.keySystems[keySystem]?.licenseServer != null
+            ? 0
+            : 1;
+    });
+}
+const messageEventValidator = object({
+    message: instanceOf(ArrayBuffer),
+});
+function hasMimeType(drmInfo) {
+    return drmInfo.mimeType != null;
+}
+/**
+ * Default initDataTransformer. For FAIR_PLAY_1_0, packs the skd init data
+ * with the extracted content ID and server certificate into the format
+ * expected by WebKit-prefixed EME. FAIR_PLAY_1_0 always uses initDataType
+ * 'skd', so we only need to check the key system.
+ * For all other key systems, returns init data unchanged.
+ */
+function defaultInitDataTransformer(keySystem, certBytes) {
+    return (initData) => {
+        if (keySystem === DrmKeySystem.FAIR_PLAY_1_0) {
+            if (!certBytes) {
+                throw new DrmError('FairPlay requires certificate data');
+            }
+            const contentId = extractContentId(initData);
+            return createFairPlaySessionInitData(initData, contentId, certBytes);
+        }
+        return initData;
+    };
+}

package/dist/types/current/drm/DrmKeySystem.d.ts

@@ -0,0 +1,61 @@
+import type { ValueSchema } from '@amazon/vinyl-validation';
+export declare enum DrmKeySystem {
+    /**
+     * Plain text encryption.
+     */
+    CLEAR_KEY = "org.w3.clearkey",
+    /**
+     * Google's Widevine.
+     */
+    WIDEVINE = "com.widevine.alpha",
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Deprecated.
+     * - Will be removed in a future release.
+     * - Non-compliant with any version of the EME specification.
+     */
+    PLAY_READY = "com.microsoft.playready",
+    /**
+     * Microsoft's PlayReady for Chromecast.
+     *
+     * - Deprecated.
+     * - Will be removed in a future release.
+     * - Non-compliant with any version of the EME specification.
+     */
+    PLAY_READY_CHROMECAST = "com.chromecast.playready",
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Security Level 2000.
+     * - Best effort compliance with latest EME specification.
+     */
+    PLAY_READY_RECOMMENDATION = "com.microsoft.playready.recommendation",
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Supported on devices with required hardware.
+     * - Security Level 3000.
+     * - Best effort compliance with latest EME specification.
+     */
+    PLAY_READY_3000 = "com.microsoft.playready.recommendation.3000",
+    /**
+     * Apple's Fairplay for modern EME.
+     */
+    FAIR_PLAY = "com.apple.fps",
+    /**
+     * Apple's Fairplay for legacy Apple Media Keys.
+     */
+    FAIR_PLAY_1_0 = "com.apple.fps.1_0"
+}
+/**
+ * Validates that the key system value is a string.
+ * While DrmKeySystem is an enum to be useful for providing known key systems,
+ * avoid strict validation to allow for unknown key systems.
+ */
+export declare const drmKeySystemValidator: ValueSchema<DrmKeySystem>;
+export declare const PLAY_READY_KEY_SYSTEMS: readonly DrmKeySystem[];
+export declare function isPlayReady(keySystem: DrmKeySystem): boolean;
+export declare const FAIR_PLAY_KEY_SYSTEMS: readonly DrmKeySystem[];
+export declare function isFairPlay(keySystem: DrmKeySystem): boolean;
+//# sourceMappingURL=DrmKeySystem.d.ts.map

package/dist/types/current/drm/DrmKeySystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrmKeySystem.d.ts","sourceRoot":"","sources":["../../../../src/drm/DrmKeySystem.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAG3D,oBAAY,YAAY;IACpB;;OAEG;IACH,SAAS,oBAAoB;IAE7B;;OAEG;IACH,QAAQ,uBAAuB;IAE/B;;;;;;OAMG;IACH,UAAU,4BAA4B;IAEtC;;;;;;OAMG;IACH,qBAAqB,6BAA6B;IAElD;;;;;OAKG;IACH,yBAAyB,2CAA2C;IAEpE;;;;;;OAMG;IACH,eAAe,gDAAgD;IAE/D;;OAEG;IACH,SAAS,kBAAkB;IAE3B;;OAEG;IACH,aAAa,sBAAsB;CACtC;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EACP,WAAW,CAAC,YAAY,CAAC,CAAA;AAEpD,eAAO,MAAM,sBAAsB,EAAE,SAAS,YAAY,EAKhD,CAAA;AAEV,wBAAgB,WAAW,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAE5D;AAED,eAAO,MAAM,qBAAqB,EAAE,SAAS,YAAY,EAG/C,CAAA;AAEV,wBAAgB,UAAU,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAE3D"}

package/dist/types/current/drm/DrmKeySystem.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { string } from '@amazon/vinyl-validation';
+export var DrmKeySystem;
+(function (DrmKeySystem) {
+    /**
+     * Plain text encryption.
+     */
+    DrmKeySystem["CLEAR_KEY"] = "org.w3.clearkey";
+    /**
+     * Google's Widevine.
+     */
+    DrmKeySystem["WIDEVINE"] = "com.widevine.alpha";
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Deprecated.
+     * - Will be removed in a future release.
+     * - Non-compliant with any version of the EME specification.
+     */
+    DrmKeySystem["PLAY_READY"] = "com.microsoft.playready";
+    /**
+     * Microsoft's PlayReady for Chromecast.
+     *
+     * - Deprecated.
+     * - Will be removed in a future release.
+     * - Non-compliant with any version of the EME specification.
+     */
+    DrmKeySystem["PLAY_READY_CHROMECAST"] = "com.chromecast.playready";
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Security Level 2000.
+     * - Best effort compliance with latest EME specification.
+     */
+    DrmKeySystem["PLAY_READY_RECOMMENDATION"] = "com.microsoft.playready.recommendation";
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Supported on devices with required hardware.
+     * - Security Level 3000.
+     * - Best effort compliance with latest EME specification.
+     */
+    DrmKeySystem["PLAY_READY_3000"] = "com.microsoft.playready.recommendation.3000";
+    /**
+     * Apple's Fairplay for modern EME.
+     */
+    DrmKeySystem["FAIR_PLAY"] = "com.apple.fps";
+    /**
+     * Apple's Fairplay for legacy Apple Media Keys.
+     */
+    DrmKeySystem["FAIR_PLAY_1_0"] = "com.apple.fps.1_0";
+})(DrmKeySystem || (DrmKeySystem = {}));
+/**
+ * Validates that the key system value is a string.
+ * While DrmKeySystem is an enum to be useful for providing known key systems,
+ * avoid strict validation to allow for unknown key systems.
+ */
+export const drmKeySystemValidator = string().notEmpty();
+export const PLAY_READY_KEY_SYSTEMS = [
+    DrmKeySystem.PLAY_READY,
+    DrmKeySystem.PLAY_READY_CHROMECAST,
+    DrmKeySystem.PLAY_READY_RECOMMENDATION,
+    DrmKeySystem.PLAY_READY_3000,
+];
+export function isPlayReady(keySystem) {
+    return PLAY_READY_KEY_SYSTEMS.includes(keySystem);
+}
+export const FAIR_PLAY_KEY_SYSTEMS = [
+    DrmKeySystem.FAIR_PLAY,
+    DrmKeySystem.FAIR_PLAY_1_0,
+];
+export function isFairPlay(keySystem) {
+    return FAIR_PLAY_KEY_SYSTEMS.includes(keySystem);
+}

package/dist/types/current/drm/DrmKeySystemResolver.d.ts

@@ -0,0 +1,12 @@
+import { type ReadonlyRecord } from '@amazon/vinyl-util';
+import { DrmKeySystem } from '../drm/DrmKeySystem';
+/**
+ * Given a ContentProtection schemeIdUri, returns the {@link DrmKeySystem} it represents.
+ * Not all scheme ids will match to a DrmKeySystem. If none are matched, null is returned.
+ * For example, CENC 'urn:mpeg:dash:mp4protection:2011' has no key system and shouldn't be used
+ * to create a key session.
+ */
+export type DrmKeySystemResolver = (schemeIdUri: string) => readonly DrmKeySystem[];
+export declare function getDefaultSchemeToKeySystem(): ReadonlyRecord<string, readonly DrmKeySystem[]>;
+export declare const defaultDrmKeySystemResolver: DrmKeySystemResolver;
+//# sourceMappingURL=DrmKeySystemResolver.d.ts.map

package/dist/types/current/drm/DrmKeySystemResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrmKeySystemResolver.d.ts","sourceRoot":"","sources":["../../../../src/drm/DrmKeySystemResolver.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EACH,YAAY,EAGf,MAAM,oBAAoB,CAAA;AAG3B;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAC/B,WAAW,EAAE,MAAM,KAClB,SAAS,YAAY,EAAE,CAAA;AAO5B,wBAAgB,2BAA2B,IAAI,cAAc,CACzD,MAAM,EACN,SAAS,YAAY,EAAE,CAC1B,CAUA;AAED,eAAO,MAAM,2BAA2B,EAAE,oBAIzC,CAAA"}

package/dist/types/current/drm/DrmKeySystemResolver.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DrmKeySystem, FAIR_PLAY_KEY_SYSTEMS, PLAY_READY_KEY_SYSTEMS, } from '../drm/DrmKeySystem';
+import { ContentProtectionScheme } from '@amazon/vinyl-mpd-parser';
+let _defaultSchemeToKeySystem = null;
+export function getDefaultSchemeToKeySystem() {
+    if (_defaultSchemeToKeySystem == null) {
+        _defaultSchemeToKeySystem = {
+            [ContentProtectionScheme.CLEAR_KEY]: [DrmKeySystem.CLEAR_KEY],
+            [ContentProtectionScheme.FAIR_PLAY]: FAIR_PLAY_KEY_SYSTEMS,
+            [ContentProtectionScheme.PLAY_READY]: PLAY_READY_KEY_SYSTEMS,
+            [ContentProtectionScheme.WIDEVINE]: [DrmKeySystem.WIDEVINE],
+        };
+    }
+    return _defaultSchemeToKeySystem;
+}
+export const defaultDrmKeySystemResolver = (schemeIdUri) => {
+    return getDefaultSchemeToKeySystem()[schemeIdUri.toLowerCase()] ?? [];
+};