@mediakind/mkplayer 1.5.0 → 1.6.0

package/types/classes/player/MKBitmovinPlayer.js

@@ -0,0 +1,1194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MKBitmovinPlayer = void 0;
+const request_1 = require("../request");
+const error_1 = require("../error");
+const common_1 = require("../common");
+const enums_1 = require("../../enums");
+const bitmovin_player_1 = require("bitmovin-player");
+const bitmovin_player_ui_1 = require("bitmovin-player-ui");
+class MKBitmovinPlayer extends common_1.MKEventBase {
+    constructor(videoContainer, playerConfig) {
+        var _a, _b, _c, _d, _e, _f;
+        super();
+        this.headers = null;
+        this.firstTimeChangedUpdate = false;
+        this.hasPreroll = false;
+        this.enableAdTrackingBeacons = true;
+        this.enableSubtitleOverlay = true;
+        this.adQuartileOffsets = [];
+        this.adTrackingList = [];
+        if (!playerConfig.key) {
+            throw new Error("Invalid player license key.");
+        }
+        this.videoContainer = videoContainer;
+        if (playerConfig.enableAdTrackingBeacons !== undefined) {
+            this.enableAdTrackingBeacons = playerConfig.enableAdTrackingBeacons;
+        }
+        this.playerUIEnabled = (_a = playerConfig.ui) !== null && _a !== void 0 ? _a : false;
+        this.enableSubtitleOverlay = this.playerUIEnabled ? false : (_b = playerConfig.enableSubtitleOverlay) !== null && _b !== void 0 ? _b : true;
+        this.playerConfig = {
+            key: playerConfig.key,
+            ui: false,
+            logs: {
+                bitmovin: false,
+                level: (_d = (_c = playerConfig.log) === null || _c === void 0 ? void 0 : _c.level) !== null && _d !== void 0 ? _d : bitmovin_player_1.LogLevel.ERROR
+            },
+            analytics: typeof (playerConfig.analytics) === "object" ? playerConfig.analytics : typeof (playerConfig.analytics) === "boolean" ? playerConfig.analytics : false,
+            live: playerConfig.live,
+            buffer: (_e = playerConfig.buffer) !== null && _e !== void 0 ? _e : MKBitmovinPlayer.DEFAULT_BUFFER_CONFIG,
+            playback: (_f = playerConfig.playback) !== null && _f !== void 0 ? _f : MKBitmovinPlayer.DEFAULT_PLAYBACK_CONFIG,
+            adaptation: playerConfig.adaptation,
+            remotecontrol: playerConfig.cast,
+            style: {
+                width: "100%",
+                aspectratio: "16:9",
+            },
+            tweaks: {
+                app_id: playerConfig.appId,
+                file_protocol: true,
+                native_hls_parsing: true,
+                enable_seek_for_live: true,
+                fairplay_ignore_duplicate_init_data_key_errors: true
+            },
+            network: {
+                preprocessHttpRequest: ((requestType, request) => {
+                    var _a, _b, _c, _d;
+                    if (request) {
+                        if (requestType === bitmovin_player_1.HttpRequestType.DRM_CERTIFICATE_FAIRPLAY || requestType === bitmovin_player_1.HttpRequestType.DRM_LICENSE_FAIRPLAY) {
+                            if (((_b = (_a = this.sourceConfig) === null || _a === void 0 ? void 0 : _a.drm) === null || _b === void 0 ? void 0 : _b.usingAzuki) !== false && this.fpsContentId && ((_d = (_c = this.sourceConfig) === null || _c === void 0 ? void 0 : _c.drm) === null || _d === void 0 ? void 0 : _d.fairplay)) {
+                                request.url = common_1.MKUtils.updateURLQueryParams(request.url, { "key_id": this.fpsContentId });
+                            }
+                        }
+                        if (requestType === bitmovin_player_1.HttpRequestType.MANIFEST_HLS_MASTER || requestType === bitmovin_player_1.HttpRequestType.MANIFEST_HLS_VARIANT) {
+                            if (this.headers && Object.keys(this.headers).length > 0) {
+                                request.headers = this.headers;
+                            }
+                        }
+                    }
+                    return Promise.resolve(request);
+                })
+            },
+            events: {
+                [bitmovin_player_1.PlayerEvent.AirplayAvailable]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AirplayAvailable, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AirplayChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AirplayChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AspectRatioChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AspectRatioChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioAdaptation]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioAdaptation, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioAdded]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioAdded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioDownloadQualityChange]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioDownloadQualityChange, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioDownloadQualityChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioDownloadQualityChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioPlaybackQualityChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioPlaybackQualityChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioQualityAdded]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioQualityAdded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioQualityChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioQualityChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioQualityRemoved]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioQualityRemoved, event);
+                },
+                [bitmovin_player_1.PlayerEvent.AudioRemoved]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.AudioRemoved, event);
+                },
+                [bitmovin_player_1.PlayerEvent.CastAvailable]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CastAvailable, event);
+                },
+                [bitmovin_player_1.PlayerEvent.CastStart]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CastStart, event);
+                },
+                [bitmovin_player_1.PlayerEvent.CastStarted]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CastStarted, event);
+                },
+                [bitmovin_player_1.PlayerEvent.CastStopped]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CastStopped, event);
+                },
+                [bitmovin_player_1.PlayerEvent.CastWaitingForDevice]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CastWaitingForDevice, event);
+                },
+                [bitmovin_player_1.PlayerEvent.DVRWindowExceeded]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.DVRWindowExceeded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Destroy]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Destroy, event);
+                },
+                [bitmovin_player_1.PlayerEvent.DownloadFinished]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.DownloadFinished, event);
+                },
+                [bitmovin_player_1.PlayerEvent.DrmLicenseAdded]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.DrmLicenseAdded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.DurationChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.DurationChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Error]: (event) => {
+                    const mkerror = new error_1.MKBitmovinPlayerError(event);
+                    const mkerrorEvent = {
+                        timestamp: event.timestamp,
+                        type: enums_1.MKPlayerEvent.Error,
+                        name: mkerror.name,
+                        code: mkerror.code,
+                        message: mkerror.message
+                    };
+                    this.emit(enums_1.MKPlayerEvent.Error, mkerrorEvent);
+                },
+                [bitmovin_player_1.PlayerEvent.LatencyModeChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.LatencyModeChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Metadata]: (event) => {
+                    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                    const metadataEvent = event;
+                    this.emit(enums_1.MKPlayerEvent.Metadata, metadataEvent);
+                    if (metadataEvent.metadataType === enums_1.MKMetadataType.DATERANGE) {
+                        const metadata = metadataEvent.metadata;
+                        if ((metadata.class === "AD-BREAK" || metadata.class === "AD" || metadata.class === "ANALYTICS") &&
+                            (metadata.clientAttributes && Object.keys(metadata.clientAttributes).length > 0)) {
+                            if (metadata.class === "AD-BREAK") {
+                                this.adQuartileOffsets = [];
+                                this.adStartedEvent = undefined;
+                                this.adBreakStartedEvent = undefined;
+                                this.adBreakStartedEvent = {
+                                    id: (_a = metadata.id.replace("-start", "")) !== null && _a !== void 0 ? _a : "",
+                                    adType: metadata.clientAttributes.adType === "pre-roll" ? enums_1.MKAdType.Preroll : metadata.clientAttributes.adType === "mid-roll" ? enums_1.MKAdType.Midroll : metadata.clientAttributes.adType === "post-roll" ? enums_1.MKAdType.Postroll : enums_1.MKAdType.Unknown,
+                                    adsCount: (_c = (_b = metadata.clientAttributes.adsCount) !== null && _b !== void 0 ? _b : metadata.clientAttributes.adIndex.split(":")[1]) !== null && _c !== void 0 ? _c : 0,
+                                    duration: (_d = metadata.duration) !== null && _d !== void 0 ? _d : 0,
+                                    offset: {
+                                        start: (_e = metadataEvent.start) !== null && _e !== void 0 ? _e : 0,
+                                        end: (_f = metadataEvent.end) !== null && _f !== void 0 ? _f : 0
+                                    },
+                                    timestamp: event.timestamp,
+                                    type: enums_1.MKPlayerEvent.AdBreakStarted
+                                };
+                                this.emit(enums_1.MKPlayerEvent.AdBreakStarted, this.adBreakStartedEvent);
+                            }
+                            if (this.adBreakStartedEvent) {
+                                if (metadata.class === "AD") {
+                                    if (this.adStartedEvent) {
+                                        const adFinishedEvent = {
+                                            id: this.adStartedEvent.id,
+                                            timestamp: common_1.MKUtils.getCurrentTimestamp(),
+                                            type: enums_1.MKPlayerEvent.AdFinished
+                                        };
+                                        this.emit(enums_1.MKPlayerEvent.AdFinished, adFinishedEvent);
+                                        this.adStartedEvent = undefined;
+                                        this.adQuartileOffsets = [];
+                                    }
+                                    this.adStartedEvent = {
+                                        id: (_h = (_g = metadata.clientAttributes.adId) !== null && _g !== void 0 ? _g : metadata.id) !== null && _h !== void 0 ? _h : "",
+                                        adIndex: (_j = metadata.clientAttributes.adIndex.split(":")[0]) !== null && _j !== void 0 ? _j : "",
+                                        title: metadata.clientAttributes.adTitle,
+                                        system: metadata.clientAttributes.adSystem,
+                                        creativeId: metadata.clientAttributes.creativeId,
+                                        creativeAdId: metadata.clientAttributes.creativeAdId,
+                                        duration: (_k = metadata.duration) !== null && _k !== void 0 ? _k : 0,
+                                        offset: {
+                                            start: (_l = metadataEvent.start) !== null && _l !== void 0 ? _l : 0,
+                                            end: (_m = metadataEvent.end) !== null && _m !== void 0 ? _m : 0
+                                        },
+                                        timestamp: event.timestamp,
+                                        type: enums_1.MKPlayerEvent.AdStarted
+                                    };
+                                    const companionAdsData = this.processCompanionAds(metadata.clientAttributes.companionAds);
+                                    if (companionAdsData) {
+                                        const companionAdEvent = {
+                                            id: this.adStartedEvent.id,
+                                            companionAd: companionAdsData,
+                                            timestamp: event.timestamp,
+                                            type: enums_1.MKPlayerEvent.AdCompanion
+                                        };
+                                        this.emit(enums_1.MKPlayerEvent.AdCompanion, companionAdEvent);
+                                    }
+                                    this.adQuartileOffsets = this.getAdQuartileOffsets(this.adStartedEvent.offset, this.adStartedEvent.duration);
+                                    this.emit(enums_1.MKPlayerEvent.AdStarted, this.adStartedEvent);
+                                }
+                                if (metadata.class === "ANALYTICS" && this.adStartedEvent) {
+                                    const adClickThroughEvent = {
+                                        id: this.adStartedEvent.id,
+                                        adClick: metadata.clientAttributes.adClick,
+                                        adClickTracking: metadata.clientAttributes.adClickTracking,
+                                        timestamp: event.timestamp,
+                                        type: enums_1.MKPlayerEvent.AdClickThrough
+                                    };
+                                    this.emit(enums_1.MKPlayerEvent.AdClickThrough, adClickThroughEvent);
+                                    if (this.enableAdTrackingBeacons) {
+                                        this.updateAdTrackingList(metadata.clientAttributes.adUrls);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                [bitmovin_player_1.PlayerEvent.MetadataChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.MetadataChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.MetadataParsed]: (event) => {
+                    var _a, _b;
+                    const metadataParsedEvent = event;
+                    if (metadataParsedEvent.metadataType === enums_1.MKMetadataType.DATERANGE &&
+                        "class" in metadataParsedEvent.metadata && metadataParsedEvent.metadata.class === "AD-BREAK" &&
+                        "clientAttributes" in metadataParsedEvent.metadata && metadataParsedEvent.metadata.clientAttributes) {
+                        const clientAttributes = metadataParsedEvent.metadata.clientAttributes;
+                        if ("adType" in clientAttributes && "adsCount" in clientAttributes) {
+                            if (clientAttributes.adType === "pre-roll")
+                                this.hasPreroll = true;
+                            const adMarkerEvent = {
+                                adMarker: {
+                                    start: (_a = metadataParsedEvent.start) !== null && _a !== void 0 ? _a : 0,
+                                    end: (_b = metadataParsedEvent.end) !== null && _b !== void 0 ? _b : 0
+                                },
+                                timestamp: common_1.MKUtils.getCurrentTimestamp(),
+                                type: enums_1.MKPlayerEvent.AdMarker
+                            };
+                            this.emit(enums_1.MKPlayerEvent.AdMarker, adMarkerEvent);
+                        }
+                    }
+                    this.emit(enums_1.MKPlayerEvent.MetadataParsed, metadataParsedEvent);
+                },
+                [bitmovin_player_1.PlayerEvent.Muted]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Muted, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Paused]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Paused, event);
+                },
+                [bitmovin_player_1.PlayerEvent.PeriodSwitch]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.PeriodSwitch, event);
+                },
+                [bitmovin_player_1.PlayerEvent.PeriodSwitched]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.PeriodSwitched, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Play]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Play, event);
+                },
+                [bitmovin_player_1.PlayerEvent.PlaybackFinished]: (event) => {
+                    var _a;
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.hide();
+                    this.emit(enums_1.MKPlayerEvent.PlaybackFinished, event);
+                },
+                [bitmovin_player_1.PlayerEvent.PlaybackSpeedChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.PlaybackSpeedChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.PlayerResized]: (event) => {
+                    var _a;
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.updateFontSize();
+                    this.emit(enums_1.MKPlayerEvent.PlayerResized, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Playing]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Playing, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Ready]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Ready, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Seek]: (event) => {
+                    var _a;
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.hide();
+                    this.emit(enums_1.MKPlayerEvent.Seek, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Seeked]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Seeked, event);
+                    this.playStart = undefined;
+                },
+                [bitmovin_player_1.PlayerEvent.SegmentPlayback]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.SegmentPlayback, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SegmentRequestFinished]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.SegmentRequestFinished, event);
+                },
+                [bitmovin_player_1.PlayerEvent.TimeShift]: (event) => {
+                    var _a;
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.hide();
+                    this.emit(enums_1.MKPlayerEvent.Seek, event);
+                },
+                [bitmovin_player_1.PlayerEvent.TimeShifted]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Seeked, event);
+                    this.playStart = undefined;
+                },
+                [bitmovin_player_1.PlayerEvent.ShowAirplayTargetPicker]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.ShowAirplayTargetPicker, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SourceLoaded]: (event) => {
+                    var _a;
+                    if (this.playerUIEnabled) {
+                        (_a = this.playerUI) === null || _a === void 0 ? void 0 : _a.release();
+                        this.playerUI = bitmovin_player_ui_1.UIFactory.buildDefaultSmallScreenUI(this.player);
+                    }
+                    const videoElement = this.getVideoElement();
+                    if (this.enableSubtitleOverlay && !this.subtitleOverlay && videoElement) {
+                        try {
+                            this.subtitleOverlay = new common_1.MKSubtitleOverlay(videoElement);
+                        }
+                        catch (error) {
+                            common_1.MKLog.error(error);
+                        }
+                    }
+                    this.emit(enums_1.MKPlayerEvent.SourceLoaded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SourceUnloaded]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.SourceUnloaded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.StallEnded]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.StallEnded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.StallStarted]: (event) => {
+                    var _a;
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.hide();
+                    this.emit(enums_1.MKPlayerEvent.StallStarted, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SubtitleAdded]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.SubtitleAdded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SubtitleDisable]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.SubtitleDisable, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SubtitleDisabled]: (event) => {
+                    var _a;
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.disable();
+                    this.emit(enums_1.MKPlayerEvent.SubtitleDisabled, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SubtitleEnable]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.SubtitleEnable, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SubtitleEnabled]: (event) => {
+                    var _a;
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.enable();
+                    this.emit(enums_1.MKPlayerEvent.SubtitleEnabled, event);
+                },
+                [bitmovin_player_1.PlayerEvent.CueEnter]: (event) => {
+                    var _a;
+                    const cueEnterEvent = event;
+                    this.emit(enums_1.MKPlayerEvent.CueEnter, cueEnterEvent);
+                    const subtitleCue = {
+                        end: cueEnterEvent.end,
+                        html: cueEnterEvent.html,
+                        image: cueEnterEvent.image,
+                        position: cueEnterEvent.position,
+                        region: cueEnterEvent.region,
+                        regionStyle: cueEnterEvent.regionStyle,
+                        start: cueEnterEvent.start,
+                        subtitleId: cueEnterEvent.subtitleId,
+                        text: cueEnterEvent.text
+                    };
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.show(subtitleCue);
+                },
+                [bitmovin_player_1.PlayerEvent.CueExit]: (event) => {
+                    var _a;
+                    this.emit(enums_1.MKPlayerEvent.CueExit, event);
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.hide();
+                },
+                [bitmovin_player_1.PlayerEvent.CueParsed]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CueParsed, event);
+                },
+                [bitmovin_player_1.PlayerEvent.CueUpdate]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CueUpdate, event);
+                },
+                [bitmovin_player_1.PlayerEvent.SubtitleRemoved]: (event) => {
+                    var _a;
+                    (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.hide();
+                    this.emit(enums_1.MKPlayerEvent.SubtitleRemoved, event);
+                },
+                [bitmovin_player_1.PlayerEvent.TargetLatencyChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.TargetLatencyChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.TimeChanged]: (event) => {
+                    const timeChangedEventdata = event;
+                    this.emit(enums_1.MKPlayerEvent.TimeChanged, timeChangedEventdata);
+                    this.emitAdEvents(timeChangedEventdata.time);
+                    if (this.enableAdTrackingBeacons) {
+                        this.notifyAdTracking(timeChangedEventdata.time);
+                    }
+                    if (!this.firstTimeChangedUpdate) {
+                        this.firstTimeChangedUpdate = true;
+                        if (this.sourceConfig && !this.hasPreroll && this.playStart !== undefined) {
+                            if (this.sourceConfig.assetType === enums_1.MKAssetType.Live || this.sourceConfig.assetType === enums_1.MKAssetType.Event) {
+                                if (this.playStart === 1) {
+                                    common_1.MKLog.debug("Will seek to live edge!");
+                                    this.seekToLiveEdge();
+                                }
+                                else {
+                                    common_1.MKLog.debug(`Will seek to offset ${this.playStart}`);
+                                    this.seek(this.playStart);
+                                }
+                            }
+                            else {
+                                common_1.MKLog.debug(`Will seek to offset ${this.playStart}`);
+                                this.seek(this.playStart);
+                            }
+                        }
+                    }
+                },
+                [bitmovin_player_1.PlayerEvent.Unmuted]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.Unmuted, event);
+                },
+                [bitmovin_player_1.PlayerEvent.VideoAdaptation]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.VideoAdaptation, event);
+                },
+                [bitmovin_player_1.PlayerEvent.VideoDownloadQualityChange]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.VideoDownloadQualityChange, event);
+                },
+                [bitmovin_player_1.PlayerEvent.VideoDownloadQualityChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.VideoDownloadQualityChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.VideoPlaybackQualityChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.VideoPlaybackQualityChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.VideoQualityAdded]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.VideoQualityAdded, event);
+                },
+                [bitmovin_player_1.PlayerEvent.VideoQualityChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.VideoQualityChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.VideoQualityRemoved]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.VideoQualityRemoved, event);
+                },
+                [bitmovin_player_1.PlayerEvent.ViewModeChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.ViewModeChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.VolumeChanged]: (event) => {
+                    this.emit(enums_1.MKPlayerEvent.VolumeChanged, event);
+                },
+                [bitmovin_player_1.PlayerEvent.Warning]: (event) => {
+                    if ("code" in event && event.code === 1401) {
+                        const mkerror = new error_1.MKBitmovinPlayerError(event);
+                        const mkerrorEvent = {
+                            timestamp: event.timestamp,
+                            type: enums_1.MKPlayerEvent.Error,
+                            name: mkerror.name,
+                            code: mkerror.code,
+                            message: mkerror.message
+                        };
+                        this.emit(enums_1.MKPlayerEvent.Error, mkerrorEvent);
+                    }
+                    else {
+                        common_1.MKLog.warn(JSON.stringify(event, null, 4));
+                    }
+                }
+            }
+        };
+        this.player = new bitmovin_player_1.Player(this.videoContainer, this.playerConfig);
+        if (this.player.getContainer().classList.contains('bitmovinplayer-container')) {
+            this.player.getContainer().classList.remove('bitmovinplayer-container');
+        }
+        if (this.player.getContainer().classList.contains('aspect-16x9')) {
+            this.player.getContainer().classList.remove('aspect-16x9');
+        }
+    }
+    addCastMetadata(metadata) {
+        return this.player.addMetadata(bitmovin_player_1.MetadataType.CAST, metadata);
+    }
+    addSubtitle(subtitleTrack) {
+        this.player.subtitles.add(subtitleTrack);
+    }
+    castStop() {
+        this.player.castStop();
+    }
+    castVideo() {
+        this.player.castVideo();
+    }
+    destroy() {
+        var _a, _b, _c;
+        (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.disable();
+        (_b = this.subtitleOverlay) === null || _b === void 0 ? void 0 : _b.destroy();
+        this.subtitleOverlay = undefined;
+        (_c = this.playerUI) === null || _c === void 0 ? void 0 : _c.release();
+        return this.player.destroy();
+    }
+    disableSubtitle(subtitleID) {
+        this.player.subtitles.disable(subtitleID);
+    }
+    enableSubtitle(subtitleID) {
+        this.player.subtitles.enable(subtitleID);
+    }
+    getAspectRatio() {
+        return this.player.getAspectRatio();
+    }
+    getAudio() {
+        const audioTrack = this.player.getAudio();
+        if (audioTrack)
+            return audioTrack;
+        return null;
+    }
+    getAudioQuality() {
+        const audioQuality = this.player.getAudioQuality();
+        return audioQuality;
+    }
+    getAvailableAudio() {
+        const audioTracks = this.player.getAvailableAudio();
+        return audioTracks;
+    }
+    getAvailableAudioQualities() {
+        const audioQualities = this.player.getAvailableAudioQualities();
+        return audioQualities;
+    }
+    getAvailableSubtitles() {
+        const subtitleTracks = this.player.subtitles.list();
+        return subtitleTracks;
+    }
+    getAvailableVideoQualities() {
+        const videoQualities = this.player.getAvailableVideoQualities();
+        return videoQualities;
+    }
+    getBufferLevel(type, media) {
+        const bufferLevel = this.player.buffer.getLevel(type, media);
+        return bufferLevel;
+    }
+    getBufferedRanges() {
+        let bufferedRanges = this.player.getBufferedRanges();
+        return bufferedRanges;
+    }
+    getVersion() {
+        return bitmovin_player_1.Player.version;
+    }
+    getVideoContainer() {
+        return this.player.getContainer();
+    }
+    getCurrentTime(mode) {
+        return this.player.getCurrentTime(mode);
+    }
+    getDownloadedAudioData() {
+        const downloadedAudioData = this.player.getDownloadedAudioData();
+        return downloadedAudioData;
+    }
+    getDownloadedVideoData() {
+        const downloadedVideoData = this.player.getDownloadedVideoData();
+        return downloadedVideoData;
+    }
+    getDroppedVideoFrames() {
+        return this.player.getDroppedVideoFrames();
+    }
+    getDuration() {
+        if (this.isLive()) {
+            return (-1 * this.getMaxTimeShift());
+        }
+        return this.player.getDuration();
+    }
+    getMaxTimeShift() {
+        return this.player.getMaxTimeShift();
+    }
+    getPlaybackAudioData() {
+        const audioQuality = this.player.getPlaybackAudioData();
+        return audioQuality;
+    }
+    getPlaybackSpeed() {
+        return this.player.getPlaybackSpeed();
+    }
+    getPlaybackVideoData() {
+        const videoQuality = this.player.getPlaybackVideoData();
+        return videoQuality;
+    }
+    getSeekableRange(mode) {
+        if (mode == enums_1.MKTimeMode.RelativeTime && this.isLive()) {
+            const end = this.getCurrentTime(mode) + (-1 * this.getTimeShift());
+            const start = end - (-1 * this.getMaxTimeShift());
+            const seekableRange = {
+                start: start < 0 ? 0 : start,
+                end: end
+            };
+            return seekableRange;
+        }
+        const seekableRange = this.player.getSeekableRange();
+        return seekableRange;
+    }
+    getThumbnail(time) {
+        const thumbnail = this.player.getThumbnail(time);
+        if (thumbnail)
+            return thumbnail;
+        return null;
+    }
+    getTimeShift() {
+        return this.player.getTimeShift();
+    }
+    getTotalStalledTime() {
+        return this.player.getTotalStalledTime();
+    }
+    getVideoElement() {
+        return this.player.getVideoElement();
+    }
+    getVideoQuality() {
+        const videoQuality = this.player.getVideoQuality();
+        return videoQuality;
+    }
+    getViewMode() {
+        const viewMode = this.player.getViewMode();
+        return viewMode;
+    }
+    getVolume() {
+        return this.player.getVolume();
+    }
+    hasEnded() {
+        return this.player.hasEnded();
+    }
+    isAirplayActive() {
+        return this.player.isAirplayActive();
+    }
+    isAirplayAvailable() {
+        return this.player.isAirplayAvailable();
+    }
+    isCastAvailable() {
+        return this.player.isCastAvailable();
+    }
+    isCasting() {
+        return this.player.isCasting();
+    }
+    isLive() {
+        return this.player.isLive();
+    }
+    isMuted() {
+        return this.player.isMuted();
+    }
+    isPaused() {
+        return this.player.isPaused();
+    }
+    isPlaying() {
+        return this.player.isPlaying();
+    }
+    isStalled() {
+        return this.player.isStalled();
+    }
+    isViewModeAvailable(viewMode) {
+        return this.player.isViewModeAvailable(viewMode);
+    }
+    load(sourceConfig, disableSeeking) {
+        var _a;
+        this.hasPreroll = false;
+        this.adTrackingList = [];
+        this.playStart = undefined;
+        this.fpsContentId = undefined;
+        this.firstTimeChangedUpdate = false;
+        this.sourceConfig = Object.assign({}, sourceConfig);
+        let applyDefaultStartOffset = true;
+        const source = {};
+        source.title = sourceConfig.title;
+        source.description = sourceConfig.description;
+        source.poster = sourceConfig.poster;
+        source.hls = sourceConfig.hls;
+        source.dash = sourceConfig.dash;
+        source.progressive = sourceConfig.progressive;
+        source.smooth = sourceConfig.smooth;
+        source.labeling = sourceConfig.labeling;
+        source.analytics = sourceConfig.analytics;
+        source.subtitleTracks = sourceConfig.subtitleTracks;
+        source.thumbnailTrack = sourceConfig.thumbnailTrack;
+        if (sourceConfig.drm) {
+            source.drm = Object.assign({}, sourceConfig.drm);
+            if (sourceConfig.drm.usingAzuki !== false && source.drm.fairplay) {
+                source.drm.fairplay.prepareContentId = ((url) => {
+                    const link = document.createElement('a');
+                    link.href = url.substring(url.indexOf("skd://"));
+                    if (link.href.length > 0) {
+                        const urlParts = link.href.split("skd://", 2);
+                        if (urlParts.length === 2) {
+                            this.fpsContentId = urlParts[1];
+                            return this.fpsContentId;
+                        }
+                    }
+                    return link.hostname;
+                });
+                source.drm.fairplay.prepareCertificate = ((data) => {
+                    var _a, _b;
+                    const responseText = String.fromCharCode.apply(null, Array.from(new Uint8Array(data)));
+                    const parser = new DOMParser();
+                    const xmlDoc = parser.parseFromString(responseText, "text/xml");
+                    const cert = (_b = (_a = xmlDoc.getElementsByTagName("cert")[0]) === null || _a === void 0 ? void 0 : _a.childNodes[0]) === null || _b === void 0 ? void 0 : _b.nodeValue;
+                    const raw = common_1.MKUtils.base64Decode(cert !== null && cert !== void 0 ? cert : "", false);
+                    const rawLength = raw.length;
+                    let certificate = new Uint8Array(new ArrayBuffer(rawLength));
+                    for (let i = 0; i < rawLength; i++) {
+                        certificate[i] = raw.charCodeAt(i);
+                    }
+                    return certificate;
+                });
+                source.drm.fairplay.prepareMessage = ((event, _session) => {
+                    return common_1.MKUtils.base64Encode(event.message);
+                });
+                source.drm.fairplay.prepareLicense = ((data) => {
+                    var _a, _b;
+                    const parser = new DOMParser();
+                    const xmlDoc = parser.parseFromString(data, "text/xml");
+                    const cert = (_b = (_a = xmlDoc.getElementsByTagName("ckc")[0]) === null || _a === void 0 ? void 0 : _a.childNodes[0]) === null || _b === void 0 ? void 0 : _b.nodeValue;
+                    return cert !== null && cert !== void 0 ? cert : "";
+                });
+            }
+        }
+        if (sourceConfig.sourceOptions !== undefined) {
+            source.options = {
+                audioCodecPriority: sourceConfig.sourceOptions.audioCodecPriority,
+                dashManifestWithCredentials: sourceConfig.sourceOptions.dashManifestWithCredentials,
+                dashWithCredentials: sourceConfig.sourceOptions.dashWithCredentials,
+                headers: sourceConfig.sourceOptions.headers,
+                hlsManifestWithCredentials: sourceConfig.sourceOptions.hlsManifestWithCredentials,
+                hlsWithCredentials: sourceConfig.sourceOptions.hlsWithCredentials,
+                manifestWithCredentials: sourceConfig.sourceOptions.manifestWithCredentials,
+                persistentPoster: sourceConfig.sourceOptions.persistentPoster,
+                shouldRecreateSourceBuffersOnPeriodSwitch: sourceConfig.sourceOptions.shouldRecreateSourceBuffersOnPeriodSwitch,
+                videoCodecPriority: sourceConfig.sourceOptions.videoCodecPriority,
+                withCredentials: sourceConfig.sourceOptions.withCredentials
+            };
+            if (sourceConfig.sourceOptions.startOffset !== undefined) {
+                applyDefaultStartOffset = false;
+                if (sourceConfig.assetType === enums_1.MKAssetType.Live || sourceConfig.assetType === enums_1.MKAssetType.Event) {
+                    if (sourceConfig.sourceOptions.startOffset < 0) {
+                        source.options.startOffset = sourceConfig.sourceOptions.startOffset;
+                        source.options.startOffsetTimelineReference = sourceConfig.sourceOptions.startOffsetTimelineReference;
+                        common_1.MKLog.debug(`Will start playback directly at offset ${sourceConfig.sourceOptions.startOffset}`);
+                    }
+                    else if (sourceConfig.sourceOptions.startOffset === 0) {
+                        if (sourceConfig.assetType === enums_1.MKAssetType.Live) {
+                            const timelineReferencePoint = (_a = sourceConfig.sourceOptions.startOffsetTimelineReference) !== null && _a !== void 0 ? _a : bitmovin_player_1.TimelineReferencePoint.End;
+                            source.options.startOffset = -1;
+                            source.options.startOffsetTimelineReference = timelineReferencePoint;
+                            common_1.MKLog.debug(`Will start playback directly from ${timelineReferencePoint === bitmovin_player_1.TimelineReferencePoint.End ? "live edge" : "beginning"} for live.`);
+                        }
+                        else {
+                            source.options.startOffset = -1;
+                            source.options.startOffsetTimelineReference = bitmovin_player_1.TimelineReferencePoint.Start;
+                            if (sourceConfig.sourceOptions.startOffsetTimelineReference === enums_1.MKStartOffsetTimelineReference.End) {
+                                this.playStart = 1;
+                                common_1.MKLog.debug("Will start playback directly from beginning, play preroll ad if available and then seek to live edge!");
+                            }
+                            else {
+                                common_1.MKLog.debug("Will start playback directly from beginning!");
+                            }
+                        }
+                    }
+                    else {
+                        this.playStart = sourceConfig.sourceOptions.startOffset;
+                        common_1.MKLog.debug(`Will play preroll if available else seek to offset ${this.playStart} as soon as playback starts!`);
+                    }
+                }
+                else {
+                    if (sourceConfig.sourceOptions.startOffset > 0) {
+                        if (sourceConfig.registered !== undefined) {
+                            this.playStart = sourceConfig.sourceOptions.startOffset;
+                            common_1.MKLog.debug(`Will play preroll if available else seek to offset ${this.playStart} as soon as playback starts!`);
+                        }
+                        else {
+                            source.options.startOffset = sourceConfig.sourceOptions.startOffset;
+                            common_1.MKLog.debug(`Will start playback directly at offset ${sourceConfig.sourceOptions.startOffset}`);
+                        }
+                    }
+                    else {
+                        common_1.MKLog.warn(`Unsupported startOffset: ${sourceConfig.sourceOptions.startOffset} specified in sourceOptions!`);
+                    }
+                }
+            }
+        }
+        if (applyDefaultStartOffset && sourceConfig.assetType === enums_1.MKAssetType.DVR) {
+            applyDefaultStartOffset = false;
+            source.options = {
+                startOffset: -1,
+                startOffsetTimelineReference: bitmovin_player_1.TimelineReferencePoint.Start
+            };
+        }
+        common_1.MKLog.debug(`Starting playback with source: ${JSON.stringify(source, null, 4)}`);
+        return this.player.load(source, undefined, disableSeeking);
+    }
+    reload(start, sourceOptions) {
+        if (!this.sourceConfig) {
+            return Promise.reject(new Error("Invalid source configuration!"));
+        }
+        const sourceConfig = Object.assign({}, this.sourceConfig);
+        sourceConfig.sourceOptions = Object.assign({}, sourceOptions);
+        if (start !== undefined) {
+            if (!this.player.isLive()) {
+                return Promise.reject(new Error("Not a live source, start time can only be specified for live!"));
+            }
+            if (!common_1.MKUtils.isValidISODateString(start)) {
+                return Promise.reject(new Error("Invalid start date-time specified!"));
+            }
+            if (!!sourceConfig.hls) {
+                sourceConfig.hls = common_1.MKUtils.updateURLQueryParams(sourceConfig.hls, { "start": start.toLocaleUpperCase(), "end": "END" });
+            }
+            if (!!sourceConfig.dash) {
+                sourceConfig.dash = common_1.MKUtils.updateURLQueryParams(sourceConfig.dash, { "start": start.toLocaleUpperCase(), "end": "END" });
+            }
+        }
+        return this.load(sourceConfig);
+    }
+    mute(issuer) {
+        this.player.mute(issuer);
+    }
+    pause(issuer) {
+        this.player.pause(issuer);
+    }
+    play(issuer) {
+        return this.player.play(issuer);
+    }
+    preload() {
+        this.player.preload();
+    }
+    removeSubtitle(subtitleID) {
+        this.player.subtitles.remove(subtitleID);
+    }
+    seek(time, issuer) {
+        if (this.isLive()) {
+            let seekableRange = this.getSeekableRange(enums_1.MKTimeMode.RelativeTime);
+            if (time > seekableRange.end) {
+                seekableRange = this.getSeekableRange();
+            }
+            let seekOffset = time - seekableRange.end;
+            seekOffset = seekOffset < this.getMaxTimeShift() ? this.getMaxTimeShift() : seekOffset > 0 ? 0 : seekOffset;
+            this.player.timeShift(seekOffset, issuer);
+            return true;
+        }
+        else {
+            return this.player.seek(time, issuer);
+        }
+    }
+    seekToLiveEdge(issuer) {
+        if (this.isLive()) {
+            this.player.timeShift(0, issuer);
+        }
+    }
+    setAspectRatio(aspectratio) {
+        this.player.setAspectRatio(aspectratio);
+    }
+    setAudio(trackID) {
+        this.player.setAudio(trackID);
+    }
+    setHttpHeaders(headers) {
+        if (headers !== null && Object.keys(headers).length > 0) {
+            if (this.headers) {
+                const existingHeaders = this.headers;
+                this.headers = Object.assign({}, existingHeaders, headers);
+            }
+            else {
+                this.headers = headers;
+            }
+            console.log("HEADERS: ", JSON.stringify(this.headers, null, 4));
+        }
+        else {
+            this.headers = null;
+        }
+    }
+    setAudioQuality(audioQualityID) {
+        this.player.setAudioQuality(audioQualityID);
+    }
+    setLogLevel(level) {
+        this.player.setLogLevel(level);
+    }
+    setPlaybackSpeed(speed) {
+        this.player.setPlaybackSpeed(speed);
+    }
+    setPosterImage(url, keepPersistent) {
+        this.player.setPosterImage(url, keepPersistent);
+    }
+    setTargetBufferLevel(type, value, media) {
+        this.player.buffer.setTargetLevel(type, value, media);
+    }
+    setVideoElement(videoElement) {
+        this.player.setVideoElement(videoElement);
+    }
+    setVideoQuality(videoQualityID) {
+        this.player.setVideoQuality(videoQualityID);
+    }
+    setViewMode(viewMode, options) {
+        const viewModeOptions = {};
+        if (options)
+            viewModeOptions;
+        this.player.setViewMode(viewMode, viewModeOptions);
+    }
+    setVolume(volume, issuer) {
+        this.player.setVolume(volume, issuer);
+    }
+    showAirplayTargetPicker() {
+        this.player.showAirplayTargetPicker();
+    }
+    unload() {
+        var _a, _b, _c;
+        (_a = this.subtitleOverlay) === null || _a === void 0 ? void 0 : _a.disable();
+        (_b = this.subtitleOverlay) === null || _b === void 0 ? void 0 : _b.destroy();
+        this.subtitleOverlay = undefined;
+        (_c = this.playerUI) === null || _c === void 0 ? void 0 : _c.release();
+        const posters = document.querySelectorAll('.bitmovinplayer-poster');
+        posters.forEach(poster => {
+            poster.remove();
+        });
+        return this.player.unload();
+    }
+    unmute(issuer) {
+        this.player.unmute(issuer);
+    }
+    getCatchupConfig() {
+        const config = this.player.lowlatency.getCatchupConfig();
+        return config;
+    }
+    getFallbackConfig() {
+        const config = this.player.lowlatency.getFallbackConfig();
+        return config;
+    }
+    getLatency() {
+        return this.player.lowlatency.getLatency();
+    }
+    getTargetLatency() {
+        return this.player.lowlatency.getTargetLatency();
+    }
+    setCatchupConfig(config) {
+        this.player.lowlatency.setCatchupConfig(config);
+    }
+    setFallbackConfig(config) {
+        this.player.lowlatency.setFallbackConfig(config);
+    }
+    setTargetLatency(latency) {
+        this.player.lowlatency.setTargetLatency(latency);
+    }
+    getAdQuartileOffsets(adOffset, adDuration) {
+        let quartileOffsets = [];
+        if (adOffset.start >= 0 && adOffset.end > 0 && adDuration > 0) {
+            quartileOffsets.push({
+                quartile: enums_1.MKAdQuartile.FirstQuartile,
+                startOffset: adOffset.start + (adDuration / 4)
+            });
+            quartileOffsets.push({
+                quartile: enums_1.MKAdQuartile.Midpoint,
+                startOffset: adOffset.start + (adDuration / 2)
+            });
+            quartileOffsets.push({
+                quartile: enums_1.MKAdQuartile.ThirdQuartile,
+                startOffset: adOffset.end - (adDuration / 4)
+            });
+        }
+        return quartileOffsets;
+    }
+    emitAdEvents(currentTime) {
+        var _a, _b;
+        if (this.adBreakStartedEvent && this.adStartedEvent) {
+            let adQuartileOffsetsLength = this.adQuartileOffsets.length;
+            while (adQuartileOffsetsLength--) {
+                if (currentTime >= this.adQuartileOffsets[adQuartileOffsetsLength].startOffset) {
+                    const adQuartileEvent = {
+                        id: (_b = (_a = this.adStartedEvent) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : "",
+                        quartile: this.adQuartileOffsets[adQuartileOffsetsLength].quartile,
+                        timestamp: common_1.MKUtils.getCurrentTimestamp(),
+                        type: enums_1.MKPlayerEvent.AdQuartile
+                    };
+                    this.emit(enums_1.MKPlayerEvent.AdQuartile, adQuartileEvent);
+                    this.adQuartileOffsets.splice(adQuartileOffsetsLength, 1);
+                }
+            }
+            if (currentTime >= this.adBreakStartedEvent.offset.end) {
+                if (this.adStartedEvent) {
+                    const adFinishedEvent = {
+                        id: this.adStartedEvent.id,
+                        timestamp: common_1.MKUtils.getCurrentTimestamp(),
+                        type: enums_1.MKPlayerEvent.AdFinished
+                    };
+                    this.emit(enums_1.MKPlayerEvent.AdFinished, adFinishedEvent);
+                    this.adStartedEvent = undefined;
+                    this.adQuartileOffsets = [];
+                }
+                const adType = this.adBreakStartedEvent.adType;
+                const adBreakFinishedEvent = {
+                    id: this.adBreakStartedEvent.id,
+                    timestamp: common_1.MKUtils.getCurrentTimestamp(),
+                    type: enums_1.MKPlayerEvent.AdBreakFinished
+                };
+                this.emit(enums_1.MKPlayerEvent.AdBreakFinished, adBreakFinishedEvent);
+                this.adBreakStartedEvent = undefined;
+                if (adType === enums_1.MKAdType.Preroll && this.sourceConfig && this.playStart !== undefined) {
+                    if (this.sourceConfig.assetType === enums_1.MKAssetType.Live || this.sourceConfig.assetType === enums_1.MKAssetType.Event) {
+                        if (this.playStart === 1) {
+                            common_1.MKLog.debug("Will seek to live edge as preroll ended!");
+                            this.seekToLiveEdge();
+                        }
+                        else {
+                            common_1.MKLog.debug(`Will seek to given offset ${this.playStart} as preroll ended!`);
+                            this.seek(this.playStart);
+                        }
+                    }
+                    else {
+                        common_1.MKLog.debug(`Will seek to given offset ${this.playStart} as preroll ended!`);
+                        this.seek(this.playStart);
+                    }
+                }
+            }
+        }
+    }
+    updateAdTrackingList(adUrls) {
+        if (!!adUrls) {
+            const urlParts = adUrls.split(" ");
+            urlParts.forEach((urlPart) => {
+                const trackingInfoParts = urlPart.split("|");
+                if (trackingInfoParts.length > 1 && this.adStartedEvent) {
+                    let offset = parseFloat(trackingInfoParts[0]);
+                    if (isNaN(offset))
+                        offset = 0;
+                    const time = this.adStartedEvent.offset.start + offset;
+                    const urls = [];
+                    for (let index = 1; index < trackingInfoParts.length; index++) {
+                        urls.push(trackingInfoParts[index]);
+                    }
+                    if (urls.length > 0) {
+                        this.adTrackingList.push({
+                            time: time,
+                            urls: urls
+                        });
+                    }
+                }
+            });
+        }
+    }
+    notifyAdTracking(currentTime) {
+        let index = this.adTrackingList.length;
+        while (index--) {
+            if (currentTime >= this.adTrackingList[index].time && this.adTrackingList[index].urls.length > 0) {
+                this.adTrackingList[index].urls.forEach((url) => {
+                    const request = new request_1.MKHttpRequest();
+                    request.get(url)
+                        .then(() => {
+                        common_1.MKLog.debug("Ad tracking beacon notified successfully.");
+                    })
+                        .catch(() => {
+                        common_1.MKLog.warn("Ad tracking beacon failed for url: ", url);
+                    });
+                });
+                this.adTrackingList.splice(index, 1);
+            }
+        }
+    }
+    companionXMLToJson(xmlString) {
+        var obj = {};
+        if (xmlString.nodeType === 1) {
+            if (xmlString.attributes.length > 0) {
+                for (var j = 0; j < xmlString.attributes.length; j++) {
+                    var attribute = xmlString.attributes.item(j);
+                    if (attribute.nodeName === "event") {
+                        obj['name'] = attribute.nodeValue;
+                    }
+                    else if (attribute.nodeName === "creativeType") {
+                        obj['type'] = attribute.nodeValue;
+                    }
+                    else {
+                        obj[attribute.nodeName] = attribute.nodeValue;
+                    }
+                }
+            }
+        }
+        else if ((xmlString.nodeType === 3 || xmlString.nodeType === 4) && xmlString.nodeValue.trim()) {
+            obj = xmlString.nodeValue.trim();
+        }
+        if (xmlString.hasChildNodes()) {
+            for (var i = 0; i < xmlString.childNodes.length; i++) {
+                var item = xmlString.childNodes.item(i);
+                if (item.nodeName === '#text')
+                    continue;
+                var nodeName;
+                switch (item.nodeName.toLowerCase()) {
+                    case 'companionads':
+                        nodeName = 'companionAds';
+                        break;
+                    case 'companion':
+                        nodeName = 'companion';
+                        break;
+                    case 'staticresource':
+                        nodeName = 'resource';
+                        break;
+                    case '#cdata-section':
+                        nodeName = 'url';
+                        break;
+                    case 'companionclickthrough':
+                        nodeName = 'clickThroughUrl';
+                        break;
+                    case 'trackingevents':
+                        nodeName = 'trackingEvents';
+                        break;
+                    case 'tracking':
+                        nodeName = 'tracking';
+                        break;
+                    default:
+                        nodeName = item.nodeName;
+                        break;
+                }
+                if (typeof (obj[nodeName]) === "undefined") {
+                    if (nodeName === 'resource') {
+                        obj[nodeName] = this.companionXMLToJson(item);
+                    }
+                    else if (nodeName === 'resource' || nodeName === 'clickThroughUrl') {
+                        obj[nodeName] = this.companionXMLToJson(item)['url'];
+                    }
+                    else if (nodeName === "tracking") {
+                        obj[nodeName] = [];
+                        obj[nodeName].push(this.companionXMLToJson(item));
+                    }
+                    else if (nodeName === 'trackingEvents') {
+                        obj[nodeName] = this.companionXMLToJson(item)['tracking'];
+                    }
+                    else if (nodeName === 'companionAds') {
+                        obj[nodeName] = this.companionXMLToJson(item)['companion'];
+                    }
+                    else if (nodeName === 'companion') {
+                        obj[nodeName] = [];
+                        obj[nodeName].push(this.companionXMLToJson(item));
+                    }
+                    else {
+                        obj[nodeName] = this.companionXMLToJson(item);
+                    }
+                }
+                else {
+                    if (typeof (obj[nodeName].push) === "undefined") {
+                        var old = obj[nodeName];
+                        obj[nodeName] = [];
+                        obj[nodeName].push(old);
+                    }
+                    obj[nodeName].push(this.companionXMLToJson(item));
+                }
+            }
+        }
+        return obj;
+    }
+    processCompanionAds(encodedCompanionAds) {
+        if (!encodedCompanionAds) {
+            return null;
+        }
+        var decodedCompanionAds;
+        try {
+            decodedCompanionAds = common_1.MKUtils.base64Decode(encodedCompanionAds);
+        }
+        catch (e) {
+            common_1.MKLog.error(`Failed to decode the encoded companion ad string. Error: ${e}`);
+            return null;
+        }
+        var parsedCompanionAds;
+        try {
+            parsedCompanionAds = new DOMParser().parseFromString(decodedCompanionAds, "text/xml");
+        }
+        catch (e) {
+            common_1.MKLog.error(`Failed to parse companion ad xml string. Error: ${e}`);
+            return null;
+        }
+        const companionAdsJSON = this.companionXMLToJson(parsedCompanionAds);
+        return companionAdsJSON && companionAdsJSON.hasOwnProperty('companionAds') ? companionAdsJSON.companionAds : null;
+    }
+}
+exports.MKBitmovinPlayer = MKBitmovinPlayer;
+MKBitmovinPlayer.DEFAULT_BUFFER_CONFIG = {
+    video: {
+        forwardduration: 20,
+        backwardduration: 12,
+    },
+    audio: {
+        forwardduration: 20,
+        backwardduration: 12,
+    },
+};
+MKBitmovinPlayer.DEFAULT_PLAYBACK_CONFIG = {
+    muted: true,
+    autoplay: true
+};
+//# sourceMappingURL=MKBitmovinPlayer.js.map