@pendo/agent 2.320.2 → 2.320.3

package/dist/pendo.module.js

@@ -3967,8 +3967,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.320.2_';
-let PACKAGE_VERSION = '2.320.2';
+let VERSION = '2.320.3_';
+let PACKAGE_VERSION = '2.320.3';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -40598,12 +40598,12 @@ function TextCapture() {
     return {
         name: 'TextCapture',
         initialize: init,
-        teardown,
-        isEnabled,
-        isTextCapturable,
-        hasWhitelist,
+        teardown: teardown,
+        isEnabled: isEnabled,
+        isTextCapturable: isTextCapturable,
+        hasWhitelist: hasWhitelist,
         serializer: textSerializer,
-        guideActivity
+        guideActivity: guideActivity
     };
     // technically not idempotent but might actually be right. not sure.
     function init(pendo, PluginAPI) {
@@ -40642,30 +40642,30 @@ function TextCapture() {
     function guideActivity(pendo, event) {
         if (!isEnabled())
             return;
-        const { _ } = pendo;
-        const eventData = event.data[0];
+        var _ = pendo._;
+        var eventData = event.data[0];
         if (eventData && eventData.type === 'guideActivity') {
-            const shownSteps = _.reduce(pendo.getActiveGuides({ channel: '*' }), (shown, guide) => {
+            var shownSteps = _.reduce(pendo.getActiveGuides({ channel: '*' }), function (shown, guide) {
                 if (guide.isShown()) {
-                    return shown.concat(_.filter(guide.steps, (step) => step.isShown()));
+                    return shown.concat(_.filter(guide.steps, function (step) { return step.isShown(); }));
                 }
                 return shown;
             }, []);
             if (!shownSteps.length)
                 return;
-            const findDomBlockInDomJson = pendo.BuildingBlocks.BuildingBlockGuides.findDomBlockInDomJson;
-            let elementJson;
-            _.find(shownSteps, (step) => {
+            var findDomBlockInDomJson_1 = pendo.BuildingBlocks.BuildingBlockGuides.findDomBlockInDomJson;
+            var elementJson_1;
+            _.find(shownSteps, function (step) {
                 if (!step.domJson)
                     return false;
-                elementJson = findDomBlockInDomJson(step.domJson, function (domJson) {
+                elementJson_1 = findDomBlockInDomJson_1(step.domJson, function (domJson) {
                     return domJson.props && domJson.props.id && domJson.props.id === eventData.props.ui_element_id;
                 });
-                return elementJson;
+                return elementJson_1;
             });
-            if (!elementJson)
+            if (!elementJson_1)
                 return;
-            eventData.props.ui_element_text = elementJson.content;
+            eventData.props.ui_element_text = elementJson_1.content;
         }
     }
     function isEnabled() {
@@ -42375,22 +42375,22 @@ const startListening = (
 };
 
 function VocPortal() {
-    let pendoGlobal;
-    let pluginAPI;
+    var pendoGlobal;
+    var pluginAPI;
     return {
         name: 'VocPortal',
-        initialize,
-        routeHandlerLookup,
-        queryMessageHandler,
-        resizeMessageHandler,
-        teardown
+        initialize: initialize,
+        routeHandlerLookup: routeHandlerLookup,
+        queryMessageHandler: queryMessageHandler,
+        resizeMessageHandler: resizeMessageHandler,
+        teardown: teardown
     };
     function initialize(pendo, PluginAPI) {
         pendoGlobal = pendo;
         pluginAPI = PluginAPI;
-        const { frameId } = PluginAPI.EventTracer.addTracerIds({});
+        var frameId = PluginAPI.EventTracer.addTracerIds({}).frameId;
         this.removeResizeEvent = pendoGlobal.attachEvent(window, 'resize', resizePortalIframe);
-        startListening('VocPortal', frameId, routeHandlerLookup, () => '*');
+        startListening('VocPortal', frameId, routeHandlerLookup, function () { return '*'; });
     }
     function routeHandlerLookup(path) {
         switch (path) {
@@ -42403,14 +42403,14 @@ function VocPortal() {
         }
     }
     function resizePortalIframe() {
-        const vocPortalRcContainer = document.getElementById('pendo-resource-center-container');
-        const vocPortalRcDOM = pendoGlobal.dom(vocPortalRcContainer);
+        var vocPortalRcContainer = document.getElementById('pendo-resource-center-container');
+        var vocPortalRcDOM = pendoGlobal.dom(vocPortalRcContainer);
         pluginAPI.sizeElements(vocPortalRcDOM);
     }
     function queryMessageHandler(_, responseHandler) {
-        const metadata = pendoGlobal.getSerializedMetadata();
-        const sandBoxMode = !!pendoGlobal.designer || pluginAPI.store.getters['preview/isInPreviewMode']();
-        const response = {
+        var metadata = pendoGlobal.getSerializedMetadata();
+        var sandBoxMode = !!pendoGlobal.designer || pluginAPI.store.getters['preview/isInPreviewMode']();
+        var response = {
             apiKey: pendoGlobal.apiKey,
             url: pendoGlobal.url.externalizeURL(),
             visitor: metadata.visitor,
@@ -42424,26 +42424,19 @@ function VocPortal() {
     }
     function resizeMessageHandler(msg) {
         try {
-            const { 'value': widthValue, 'unit': widthUnit, 'isImportant': widthIsImportant } = msg.data.width;
-            const { 'value': heightValue, 'unit': heightUnit, 'isImportant': heightIsImportant } = msg.data.height;
+            var _a = msg.data.width, widthValue = _a["value"], widthUnit = _a["unit"], widthIsImportant = _a["isImportant"];
+            var _b = msg.data.height, heightValue = _b["value"], heightUnit = _b["unit"], heightIsImportant = _b["isImportant"];
             if (typeof widthValue !== 'number' || typeof heightValue !== 'number') {
                 return;
             }
-            const validUnits = ['px', '%', 'vh', 'vw'];
+            var validUnits = ['px', '%', 'vh', 'vw'];
             if (!pendoGlobal._.contains(validUnits, widthUnit) || !pendoGlobal._.contains(validUnits, heightUnit)) {
                 return;
             }
-            const width = `${widthValue}${widthUnit}${widthIsImportant ? ' !important' : ''}`;
-            const height = `${heightValue}${heightUnit}${heightIsImportant ? ' !important' : ''}`;
-            const container = document.getElementById('pendo-resource-center-container');
-            pluginAPI.util.addInlineStyles('pendo-voc-portal-styles', `#pendo-resource-center-container:has(iframe[src*="portal"][src*="mode=rc"]) {
-                    width: ${width};
-                    height: ${height};
-                    ._pendo-step-container-size {
-                        width: ${width};
-                        height: ${height};
-                    }
-                }`, container);
+            var width = "".concat(widthValue).concat(widthUnit).concat(widthIsImportant ? ' !important' : '');
+            var height = "".concat(heightValue).concat(heightUnit).concat(heightIsImportant ? ' !important' : '');
+            var container = document.getElementById('pendo-resource-center-container');
+            pluginAPI.util.addInlineStyles('pendo-voc-portal-styles', "#pendo-resource-center-container:has(iframe[src*=\"portal\"][src*=\"mode=rc\"]) {\n                    width: ".concat(width, ";\n                    height: ").concat(height, ";\n                    ._pendo-step-container-size {\n                        width: ").concat(width, ";\n                        height: ").concat(height, ";\n                    }\n                }"), container);
             resizePortalIframe();
         }
         catch (err) {
@@ -46492,7 +46485,10 @@ function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetM
             removes: [{ index: index2 }]
           });
         }
-        return target.apply(thisArg, argumentsList);
+        try {
+          return target.apply(thisArg, argumentsList);
+        } catch (e2) {
+        }
       }
     )
   });
@@ -46621,7 +46617,10 @@ function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetM
                 ]
               });
             }
-            return target.apply(thisArg, argumentsList);
+            try {
+              return target.apply(thisArg, argumentsList);
+            } catch (e2) {
+            }
           }
         )
       }
@@ -48627,61 +48626,6 @@ var n;
 }(n || (n = {}));
   return record; }
 
-var SessionRecorderBuffer = /** @class */ (function () {
-    function SessionRecorderBuffer(interval, maxCount) {
-        if (maxCount === void 0) { maxCount = Infinity; }
-        this.data = [];
-        this.sequenceNumber = 0;
-        this.interval = interval;
-        this.maxCount = maxCount;
-        this.doubledMaxCount = maxCount * 2;
-    }
-    SessionRecorderBuffer.prototype.isEmpty = function () {
-        return this.data.length === 0;
-    };
-    SessionRecorderBuffer.prototype.count = function () {
-        return this.data.length;
-    };
-    SessionRecorderBuffer.prototype.clear = function () {
-        this.data.length = 0;
-    };
-    SessionRecorderBuffer.prototype.clearSequence = function () {
-        this.sequenceNumber = 0;
-    };
-    SessionRecorderBuffer.prototype.push = function (event) {
-        this.data.push(event);
-        this.checkRateLimit();
-    };
-    SessionRecorderBuffer.prototype.pack = function (envelope, _) {
-        var eventsToSend = this.data.splice(0, this.maxCount);
-        envelope.recordingPayload = eventsToSend;
-        envelope.sequence = this.sequenceNumber;
-        envelope.recordingPayloadCount = eventsToSend.length;
-        if (eventsToSend.length) {
-            envelope.browserTime = eventsToSend[0].timestamp;
-        }
-        envelope.recordingPayloadMetadata = _.map(eventsToSend, function (event) {
-            var metadata = _.pick(event, 'type', 'timestamp');
-            if (event.data) {
-                metadata.data = _.pick(event.data, 'source', 'type', 'x', 'y', 'id', 'height', 'width', 'href');
-            }
-            return metadata;
-        });
-        this.sequenceNumber += eventsToSend.length;
-        return envelope;
-    };
-    SessionRecorderBuffer.prototype.checkRateLimit = function () {
-        var length = this.data.length;
-        if (length >= this.doubledMaxCount && length % this.maxCount === 0) {
-            var elapsed = this.data[length - 1].timestamp - this.data[length - this.doubledMaxCount].timestamp;
-            if (elapsed <= this.interval && this.onRateLimit) {
-                this.onRateLimit();
-            }
-        }
-    };
-    return SessionRecorderBuffer;
-}());
-
 var __assign = function() {
     __assign = Object.assign || function __assign(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -48748,6 +48692,61 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+var SessionRecorderBuffer = /** @class */ (function () {
+    function SessionRecorderBuffer(interval, maxCount) {
+        if (maxCount === void 0) { maxCount = Infinity; }
+        this.data = [];
+        this.sequenceNumber = 0;
+        this.interval = interval;
+        this.maxCount = maxCount;
+        this.doubledMaxCount = maxCount * 2;
+    }
+    SessionRecorderBuffer.prototype.isEmpty = function () {
+        return this.data.length === 0;
+    };
+    SessionRecorderBuffer.prototype.count = function () {
+        return this.data.length;
+    };
+    SessionRecorderBuffer.prototype.clear = function () {
+        this.data.length = 0;
+    };
+    SessionRecorderBuffer.prototype.clearSequence = function () {
+        this.sequenceNumber = 0;
+    };
+    SessionRecorderBuffer.prototype.push = function (event) {
+        this.data.push(event);
+        this.checkRateLimit();
+    };
+    SessionRecorderBuffer.prototype.pack = function (envelope, _) {
+        var eventsToSend = this.data.splice(0, this.maxCount);
+        envelope.recordingPayload = eventsToSend;
+        envelope.sequence = this.sequenceNumber;
+        envelope.recordingPayloadCount = eventsToSend.length;
+        if (eventsToSend.length) {
+            envelope.browserTime = eventsToSend[0].timestamp;
+        }
+        envelope.recordingPayloadMetadata = _.map(eventsToSend, function (event) {
+            var metadata = _.pick(event, 'type', 'timestamp');
+            if (event.data) {
+                metadata.data = _.pick(event.data, 'source', 'type', 'x', 'y', 'id', 'height', 'width', 'href');
+            }
+            return metadata;
+        });
+        this.sequenceNumber += eventsToSend.length;
+        return envelope;
+    };
+    SessionRecorderBuffer.prototype.checkRateLimit = function () {
+        var length = this.data.length;
+        if (length >= this.doubledMaxCount && length % this.maxCount === 0) {
+            var elapsed = this.data[length - 1].timestamp - this.data[length - this.doubledMaxCount].timestamp;
+            if (elapsed <= this.interval && this.onRateLimit) {
+                this.onRateLimit();
+            }
+        }
+    };
+    return SessionRecorderBuffer;
+}());
+
 var RECORDING_CONFIG_WORKERURL$1 = 'recording.workerUrl';
 var MAX_SIZE = 2000000;
 var RESOURCE_CACHING$1 = 'resourceCaching';
@@ -48982,33 +48981,33 @@ function maskText(options, text, element) {
     return text;
 }
 
-const RECORDING_CONFIG = 'recording';
-const RECORDING_CONFIG_ENABLED = 'recording.enabled';
-const RECORDING_CONFIG_AUTO_START = 'recording.autoStart';
-const RECORDING_CONFIG_WORKERURL = 'recording.workerUrl';
-const RECORDING_CONFIG_ON_RECORDING_START = 'recording.onRecordingStart';
-const RECORDING_CONFIG_ON_RECORDING_STOP = 'recording.onRecordingStop';
-const RECORDING_CONFIG_WORKER_OVERRIDE = 'recording.workerOverride';
-const RECORDING_CONFIG_TREAT_IFRAME_AS_ROOT = 'recording.treatIframeAsRoot';
-const RECORDING_CONFIG_DISABLE_UNLOAD = 'recording.disableUnload';
-const RESOURCE_CACHING = 'resourceCaching';
-const ONE_DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1000;
-const ONE_MINUTE_IN_MILLISECONDS = 60 * 1000;
-const THIRTY_MINUTES = 1000 * 60 * 30;
-const ONE_HUNDRED_MB_IN_BYTES = 100 * 1024 * 1024;
-const SESSION_RECORDING_ID = 'pendo_srId';
-const SESSION_RECORDING_LAST_USER_INTERACTION_EVENT = 'pendo_srLastUserInteractionEvent';
-const SEND_INTERVAL = 5000;
-const MAX_SEND_COUNT = 20000;
-const EVENT_TYPES = {
+var RECORDING_CONFIG = 'recording';
+var RECORDING_CONFIG_ENABLED = 'recording.enabled';
+var RECORDING_CONFIG_AUTO_START = 'recording.autoStart';
+var RECORDING_CONFIG_WORKERURL = 'recording.workerUrl';
+var RECORDING_CONFIG_ON_RECORDING_START = 'recording.onRecordingStart';
+var RECORDING_CONFIG_ON_RECORDING_STOP = 'recording.onRecordingStop';
+var RECORDING_CONFIG_WORKER_OVERRIDE = 'recording.workerOverride';
+var RECORDING_CONFIG_TREAT_IFRAME_AS_ROOT = 'recording.treatIframeAsRoot';
+var RECORDING_CONFIG_DISABLE_UNLOAD = 'recording.disableUnload';
+var RESOURCE_CACHING = 'resourceCaching';
+var ONE_DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1000;
+var ONE_MINUTE_IN_MILLISECONDS = 60 * 1000;
+var THIRTY_MINUTES = 1000 * 60 * 30;
+var ONE_HUNDRED_MB_IN_BYTES = 100 * 1024 * 1024;
+var SESSION_RECORDING_ID = 'pendo_srId';
+var SESSION_RECORDING_LAST_USER_INTERACTION_EVENT = 'pendo_srLastUserInteractionEvent';
+var SEND_INTERVAL = 5000;
+var MAX_SEND_COUNT = 20000;
+var EVENT_TYPES = {
     INCREMENTAL_SOURCE_MUTATION: 0,
     FULL_SNAPSHOT: 2,
     INCREMENTAL_SNAPSHOT: 3,
     META: 4,
     INCREMENTAL_SOURCE_INPUT: 5
 };
-class SessionRecorder {
-    constructor(rrwebRecord, WorkerClass) {
+var SessionRecorder = /** @class */ (function () {
+    function SessionRecorder(rrwebRecord, WorkerClass) {
         this.name = 'Replay';
         this.record = rrwebRecord;
         this.WorkerClass = WorkerClass;
@@ -49016,8 +49015,8 @@ class SessionRecorder {
         this.eventsSinceLastKeyFrame = 0;
         this.currentRecordingSize = 0;
     }
-    addConfigOptions() {
-        const cf = this.api.ConfigReader;
+    SessionRecorder.prototype.addConfigOptions = function () {
+        var cf = this.api.ConfigReader;
         cf.addOption(RECORDING_CONFIG, [cf.sources.PENDO_CONFIG_SRC], {});
         /**
          * Determines if replay will immediately begin collecting data. If false, you can resume collecting
@@ -49103,12 +49102,12 @@ class SessionRecorder {
          */
         cf.addOption(RECORDING_CONFIG_TREAT_IFRAME_AS_ROOT, [cf.sources.SNIPPET_SRC], undefined);
         cf.addOption(RESOURCE_CACHING, [cf.sources.PENDO_CONFIG_SRC], undefined);
-    }
-    initialize(pendo, PluginAPI) {
+    };
+    SessionRecorder.prototype.initialize = function (pendo, PluginAPI) {
         this.pendo = pendo;
         this.api = PluginAPI;
-        const bind = this.pendo._.bind;
-        const configReader = this.api.ConfigReader;
+        var bind = this.pendo._.bind;
+        var configReader = this.api.ConfigReader;
         this.buffer = new SessionRecorderBuffer(SEND_INTERVAL, MAX_SEND_COUNT);
         this.buffer.onRateLimit = bind(this.rateLimitExceeded, this);
         this.transport = new Transport(this.WorkerClass, this.pendo, this.api);
@@ -49126,8 +49125,8 @@ class SessionRecorder {
             ? configReader.get(RECORDING_CONFIG_ON_RECORDING_START) : function () { };
         this.onRecordingStop = this.pendo._.isFunction(configReader.get(RECORDING_CONFIG_ON_RECORDING_STOP))
             ? configReader.get(RECORDING_CONFIG_ON_RECORDING_STOP) : function () { };
-        let isSessionReplayEnabled = false;
-        const snippetOverrideValue = configReader.get(RECORDING_CONFIG_ENABLED);
+        var isSessionReplayEnabled = false;
+        var snippetOverrideValue = configReader.get(RECORDING_CONFIG_ENABLED);
         // The snippet config value should take precedence over whatever value the backend returns,
         // but ONLY for replay being enabled - all other values should be taken from the backend
         if (this.pendo._.isBoolean(snippetOverrideValue)) {
@@ -49146,7 +49145,7 @@ class SessionRecorder {
             this.api.log.info('Session Replay is disabled because excludeNonGuideAnalytics is enabled');
             return;
         }
-        const sessionIdKey = this.sessionIdKey = `${SESSION_RECORDING_ID}.${this.pendo.apiKey}`;
+        var sessionIdKey = this.sessionIdKey = "".concat(SESSION_RECORDING_ID, ".").concat(this.pendo.apiKey);
         this.pendo.recording = {
             start: bind(this.start, this),
             stop: bind(this.stop, this)
@@ -49187,8 +49186,8 @@ class SessionRecorder {
          * @label SESSION_RECORDING_LAST_USER_INTERACTION_EVENT
          */
         this.api.agentStorage.registry.addSession(SESSION_RECORDING_LAST_USER_INTERACTION_EVENT);
-    }
-    teardown() {
+    };
+    SessionRecorder.prototype.teardown = function () {
         delete this.pendo.recording;
         delete this.allowStart;
         this.pendo._.each(this.subscriptions, function (unsubscribe) {
@@ -49198,35 +49197,36 @@ class SessionRecorder {
         this.subscriptions.length = 0;
         this.stop();
         this.transport.stop();
-    }
-    ready() {
+    };
+    SessionRecorder.prototype.ready = function () {
         if (this.api.ConfigReader.get(RECORDING_CONFIG_AUTO_START) !== false) {
             this.start();
         }
-    }
-    addPageLifecycleListeners() {
+    };
+    SessionRecorder.prototype.addPageLifecycleListeners = function () {
+        var _this = this;
         // It's important these event listeners use the capture phase, so making it explicit.
-        const useCapture = true;
-        this.pendo._.each(['pageshow', 'focus', 'blur', 'visibilitychange', 'resume'], (type) => {
-            this.pageLifecycleListeners.push(this.api.attachEventInternal(window, type, this.pendo._.bind(this.checkPageLifecycleState, this), useCapture));
+        var useCapture = true;
+        this.pendo._.each(['pageshow', 'focus', 'blur', 'visibilitychange', 'resume'], function (type) {
+            _this.pageLifecycleListeners.push(_this.api.attachEventInternal(window, type, _this.pendo._.bind(_this.checkPageLifecycleState, _this), useCapture));
         });
-    }
-    removePageLifecycleListeners() {
+    };
+    SessionRecorder.prototype.removePageLifecycleListeners = function () {
         this.pendo._.each(this.pageLifecycleListeners, function (teardownFn) {
             teardownFn();
         });
         this.pageLifecycleListeners = [];
-    }
-    checkPageLifecycleState() {
-        const state = this.getPageLifecycleState();
+    };
+    SessionRecorder.prototype.checkPageLifecycleState = function () {
+        var state = this.getPageLifecycleState();
         if (state === 'active' || state === 'passive') {
             if (!this.isRecording() && this.allowStart) {
                 this.removePageLifecycleListeners();
                 this.ready();
             }
         }
-    }
-    getPageLifecycleState() {
+    };
+    SessionRecorder.prototype.getPageLifecycleState = function () {
         if (document.visibilityState === 'hidden') {
             return 'hidden';
         }
@@ -49234,8 +49234,9 @@ class SessionRecorder {
             return 'active';
         }
         return 'passive';
-    }
-    changeIdentity(identifyEvent) {
+    };
+    SessionRecorder.prototype.changeIdentity = function (identifyEvent) {
+        var _this = this;
         if (!this.allowStart)
             return;
         clearTimeout(this._changeIdentityTimer);
@@ -49250,55 +49251,56 @@ class SessionRecorder {
         }
         this.visitorId = identifyEvent.data[0].visitor_id;
         this.accountId = identifyEvent.data[0].account_id;
-        this._changeIdentityTimer = setTimeout$1(() => {
-            this._start();
+        this._changeIdentityTimer = setTimeout$1(function () {
+            _this._start();
         }, 500);
-    }
-    changeMetadata(metadataEvent) {
-        const { hashChanged, options } = metadataEvent.data[0];
+    };
+    SessionRecorder.prototype.changeMetadata = function (metadataEvent) {
+        var _a = metadataEvent.data[0], hashChanged = _a.hashChanged, options = _a.options;
         if (this.allowStart && hashChanged) {
             clearTimeout(this._changeIdentityTimer);
             this.visitorId = options.visitor.id;
             this.accountId = options.account.id;
             return this.checkVisitorEligibility();
         }
-    }
-    checkVisitorEligibility(continuationCallback) {
+    };
+    SessionRecorder.prototype.checkVisitorEligibility = function (continuationCallback) {
+        var _this = this;
         if (!this.isRecording() && this.pendo._.isNull(this.visitorId) && this.pendo._.isNull(this.accountId))
             return;
         this.isCheckingVisitorEligibility = true;
-        return this.fetchVisitorConfig().then(visitorConfig => {
-            if ((!visitorConfig || !visitorConfig.enable) && this.isRecording()) {
-                this.stop();
+        return this.fetchVisitorConfig().then(function (visitorConfig) {
+            if ((!visitorConfig || !visitorConfig.enable) && _this.isRecording()) {
+                _this.stop();
             }
-            if (visitorConfig && visitorConfig.enable && this.isRecording()) {
+            if (visitorConfig && visitorConfig.enable && _this.isRecording()) {
                 if (continuationCallback) {
-                    continuationCallback.call(this);
+                    continuationCallback.call(_this);
                 }
-                this.api.Events.trigger('recording:unpaused');
+                _this.api.Events.trigger('recording:unpaused');
             }
-            if (visitorConfig && visitorConfig.enable && !this.isRecording()) {
-                this._startRecordingForVisitor(visitorConfig);
+            if (visitorConfig && visitorConfig.enable && !_this.isRecording()) {
+                _this._startRecordingForVisitor(visitorConfig);
             }
-            this.isCheckingVisitorEligibility = false;
-        }).catch((e) => {
-            this.isCheckingVisitorEligibility = false;
-            this.api.log.critical('Failed to re-fetch recording config', { error: e });
-            this.logStopReason('VISITOR_CONFIG_ERROR');
+            _this.isCheckingVisitorEligibility = false;
+        })["catch"](function (e) {
+            _this.isCheckingVisitorEligibility = false;
+            _this.api.log.critical('Failed to re-fetch recording config', { error: e });
+            _this.logStopReason('VISITOR_CONFIG_ERROR');
         });
-    }
-    snapshot() {
+    };
+    SessionRecorder.prototype.snapshot = function () {
         if (!this.isRecording())
             return;
         this.send();
         this.record.takeFullSnapshot();
-    }
-    isRecording() {
+    };
+    SessionRecorder.prototype.isRecording = function () {
         return this.interval != null;
-    }
-    recordingConfig(visitorConfig) {
-        const recordingOptions = this.pendo._.extend({}, this.config.options, visitorConfig);
-        const maskOptions = {
+    };
+    SessionRecorder.prototype.recordingConfig = function (visitorConfig) {
+        var recordingOptions = this.pendo._.extend({}, this.config.options, visitorConfig);
+        var maskOptions = {
             maskAllText: recordingOptions.privateByDefault != null ? recordingOptions.privateByDefault : true,
             maskTextSelector: ['.pendo-sr-mask'].concat(recordingOptions.maskedSelectors || []).join(','),
             unmaskTextSelector: ['.pendo-sr-unmask'].concat(recordingOptions.unmaskedSelectors || []).join(','),
@@ -49313,9 +49315,9 @@ class SessionRecorder {
             password: true,
             tel: true
         });
-        const blockedSelectors = ['.pendo-ignore', '.pendo-sr-ignore'].concat(recordingOptions.blockedSelectors || []);
-        const hiddenSelectors = ['.pendo-sr-hide'].concat(recordingOptions.hiddenSelectors || []);
-        const config = {
+        var blockedSelectors = ['.pendo-ignore', '.pendo-sr-ignore'].concat(recordingOptions.blockedSelectors || []);
+        var hiddenSelectors = ['.pendo-sr-hide'].concat(recordingOptions.hiddenSelectors || []);
+        var config = {
             maskInputFn: this.pendo._.partial(maskInput, maskOptions),
             maskTextFn: this.pendo._.partial(maskText, maskOptions),
             maskTextSelector: '*',
@@ -49329,7 +49331,7 @@ class SessionRecorder {
             emitFromIframe: !!this.api.ConfigReader.get(RECORDING_CONFIG_TREAT_IFRAME_AS_ROOT)
         };
         return config;
-    }
+    };
     /**
      * Used to start collecting replay data.
      *
@@ -49339,67 +49341,71 @@ class SessionRecorder {
      * @example
      * pendo.recording.start()
      */
-    start() {
+    SessionRecorder.prototype.start = function () {
         this._restartPtm = this.api.analytics.ptm().pause();
         this.allowStart = true;
         this.visitorId = this.pendo.get_visitor_id();
         this.accountId = this.pendo.get_account_id();
         this._start();
-    }
-    _markEvents(events) {
+    };
+    SessionRecorder.prototype._markEvents = function (events) {
         if (!this.recordingId || !this.isRecording())
             return;
-        for (var e of events) {
+        for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
+            var e = events_1[_i];
             if ((e.visitor_id === this.visitorId || e.visitorId === this.visitorId) && e.type !== 'identify') {
                 e.recordingId = this.recordingId;
                 e.recordingSessionId = this.sessionId(this.recordingId);
             }
         }
-    }
-    restartPtm() {
+    };
+    SessionRecorder.prototype.restartPtm = function () {
         if (this.pendo._.isFunction(this._restartPtm)) {
             this._markEvents(this.pendo.buffers.events);
-            for (var silo of this.pendo.buffers.silos) {
+            for (var _i = 0, _a = this.pendo.buffers.silos; _i < _a.length; _i++) {
+                var silo = _a[_i];
                 this._markEvents(silo);
             }
             this._restartPtm();
             this._restartPtm = null;
         }
-    }
-    _start() {
+    };
+    SessionRecorder.prototype._start = function () {
+        var _this = this;
         if (this.isRecording())
             return;
         if (!this.pendo.isSendingEvents())
             return;
         if (!this.allowStart)
             return;
-        return this.fetchVisitorConfig().then(visitorConfig => {
-            if (!this.allowStart)
+        return this.fetchVisitorConfig().then(function (visitorConfig) {
+            if (!_this.allowStart)
                 return;
             if (!visitorConfig || !visitorConfig.enable) {
-                this.restartPtm();
-                this.logStopReason('VISITOR_DISABLED');
+                _this.restartPtm();
+                _this.logStopReason('VISITOR_DISABLED');
                 return;
             }
-            this._startRecordingForVisitor(visitorConfig);
-        }).catch((e) => {
-            this.restartPtm();
+            _this._startRecordingForVisitor(visitorConfig);
+        })["catch"](function (e) {
+            _this.restartPtm();
             if (e && /Failed to fetch/.test(e.toString())) {
                 return;
             }
-            this.api.log.critical('Failed to fetch recording config', {
+            _this.api.log.critical('Failed to fetch recording config', {
                 error: e,
-                visitorId: this.visitorId,
-                accountId: this.accountId,
-                url: this.pendo.url.get()
+                visitorId: _this.visitorId,
+                accountId: _this.accountId,
+                url: _this.pendo.url.get()
             });
-            this.logStopReason('VISITOR_CONFIG_ERROR');
+            _this.logStopReason('VISITOR_CONFIG_ERROR');
         });
-    }
-    _startRecordingForVisitor(visitorConfig) {
+    };
+    SessionRecorder.prototype._startRecordingForVisitor = function (visitorConfig) {
+        var _this = this;
         this.api.Events.trigger('recording:unpaused');
         this.transport.start(this.config);
-        const disableFallback = this.pendo._.get(this.config, 'disableFallback', true);
+        var disableFallback = this.pendo._.get(this.config, 'disableFallback', true);
         if (disableFallback && !this.transport.worker) {
             this.restartPtm();
             this.pendo.log('Worker failed to start and main thread fallback is disabled. Recording prevented from starting.');
@@ -49411,9 +49417,9 @@ class SessionRecorder {
             this.visitorConfig = visitorConfig;
             this.clearOldSessionId();
             this.sendQueue.start();
-            this.interval = setInterval(() => {
-                if (!this.sendQueue.failed()) {
-                    this.send();
+            this.interval = setInterval(function () {
+                if (!_this.sendQueue.failed()) {
+                    _this.send();
                 }
             }, SEND_INTERVAL);
             var config = this.recordingConfig(visitorConfig);
@@ -49428,8 +49434,8 @@ class SessionRecorder {
             this.restartPtm();
             this.logStopReason('RECORDING_ERROR');
         }
-    }
-    _sendIds() {
+    };
+    SessionRecorder.prototype._sendIds = function () {
         if (window != window.top)
             return;
         this.api.frames.getChannel().postMessage({
@@ -49438,16 +49444,16 @@ class SessionRecorder {
             _sessionId: this._sessionId,
             topId: this.api.store.state.frames.topId
         });
-    }
-    _refreshIds() {
+    };
+    SessionRecorder.prototype._refreshIds = function () {
         if (window == window.top)
             return;
         this.api.frames.getChannel().postMessage({
             type: 'pendo:sr:refresh'
         });
-    }
-    _frameMessage(e) {
-        const message = e.data;
+    };
+    SessionRecorder.prototype._frameMessage = function (e) {
+        var message = e.data;
         if (message.type === 'pendo:sr:id') {
             // When useBroadcastChannel is true, code in filterCrossWindowMessages restricts messages to frames in the
             // current browser window/tab. Due to a race condition in clone-detection, you can have two tabs that
@@ -49463,17 +49469,18 @@ class SessionRecorder {
         else if (message.type === 'pendo:sr:refresh' && window == window.top) {
             this._sendIds();
         }
-    }
-    clearSessionId() {
+    };
+    SessionRecorder.prototype.clearSessionId = function () {
         delete this._sessionId;
         this.api.sessionStorage.removeItem(SESSION_RECORDING_ID);
         this.api.sessionStorage.removeItem(this.sessionIdKey);
-    }
-    sessionId(defaultId = this.pendo.randomString(16)) {
+    };
+    SessionRecorder.prototype.sessionId = function (defaultId) {
+        if (defaultId === void 0) { defaultId = this.pendo.randomString(16); }
         if (!this._sessionId) {
-            let currentSessionId = this.api.sessionStorage.getItem(this.sessionIdKey);
+            var currentSessionId = this.api.sessionStorage.getItem(this.sessionIdKey);
             if (!currentSessionId) {
-                let legacySessionId = this.api.sessionStorage.getItem(SESSION_RECORDING_ID);
+                var legacySessionId = this.api.sessionStorage.getItem(SESSION_RECORDING_ID);
                 if (legacySessionId) {
                     currentSessionId = legacySessionId;
                     this.api.sessionStorage.removeItem(SESSION_RECORDING_ID);
@@ -49486,41 +49493,41 @@ class SessionRecorder {
             this._sessionId = currentSessionId;
         }
         return this._sessionId;
-    }
-    clearOldSessionId() {
-        let lastUserInteractionEventInfo = this.getLastUserInteractionEventInformation();
+    };
+    SessionRecorder.prototype.clearOldSessionId = function () {
+        var lastUserInteractionEventInfo = this.getLastUserInteractionEventInformation();
         if (lastUserInteractionEventInfo) {
-            const lastEmitTime = lastUserInteractionEventInfo.timestamp;
-            const sameVisitor = lastUserInteractionEventInfo.visitorId === this.visitorId && lastUserInteractionEventInfo.accountId === this.accountId;
-            const withinInactivityLimit = lastEmitTime > Date.now() - this.pendo._.get(this.visitorConfig, 'inactivityDuration', THIRTY_MINUTES);
+            var lastEmitTime = lastUserInteractionEventInfo.timestamp;
+            var sameVisitor = lastUserInteractionEventInfo.visitorId === this.visitorId && lastUserInteractionEventInfo.accountId === this.accountId;
+            var withinInactivityLimit = lastEmitTime > Date.now() - this.pendo._.get(this.visitorConfig, 'inactivityDuration', THIRTY_MINUTES);
             if (sameVisitor && withinInactivityLimit)
                 return;
         }
         this.clearSessionInfo();
         this.isNewSession = true;
-    }
-    clearSessionInfo() {
+    };
+    SessionRecorder.prototype.clearSessionInfo = function () {
         this.currentRecordingSize = 0;
         this.clearSessionId();
         this.clearLastUserInteractionEventInformation();
-    }
-    isUserInteraction(event) {
+    };
+    SessionRecorder.prototype.isUserInteraction = function (event) {
         if (event.type !== EVENT_TYPES.INCREMENTAL_SNAPSHOT) {
             return false;
         }
         return event.data.source > EVENT_TYPES.INCREMENTAL_SOURCE_MUTATION && event.data.source <= EVENT_TYPES.INCREMENTAL_SOURCE_INPUT;
-    }
-    storeLastUserInteractionEventInformation(event, visitorId, accountId, skipUserInteractionCheck) {
+    };
+    SessionRecorder.prototype.storeLastUserInteractionEventInformation = function (event, visitorId, accountId, skipUserInteractionCheck) {
         if (this.isUserInteraction(event) || skipUserInteractionCheck) {
-            this.lastUserInteractionEventInfo = { timestamp: event.timestamp, visitorId, accountId };
+            this.lastUserInteractionEventInfo = { timestamp: event.timestamp, visitorId: visitorId, accountId: accountId };
             this.api.sessionStorage.setItem(SESSION_RECORDING_LAST_USER_INTERACTION_EVENT, JSON.stringify(this.lastUserInteractionEventInfo));
         }
-    }
-    clearLastUserInteractionEventInformation() {
+    };
+    SessionRecorder.prototype.clearLastUserInteractionEventInformation = function () {
         delete this.lastUserInteractionEventInfo;
         this.api.sessionStorage.removeItem(SESSION_RECORDING_LAST_USER_INTERACTION_EVENT);
-    }
-    getLastUserInteractionEventInformation() {
+    };
+    SessionRecorder.prototype.getLastUserInteractionEventInformation = function () {
         if (this.lastUserInteractionEventInfo)
             return this.lastUserInteractionEventInfo;
         try {
@@ -49530,7 +49537,7 @@ class SessionRecorder {
         catch (e) { // nothing here yet or failed to be written; don't need to log
             return null;
         }
-    }
+    };
     /**
      * Handle new rrweb events coming in. This will also make sure that we are properly sending a "keyframe"
      * as the BE expects it. A "keyframe" should consist of only the events needed to start a recording. This includes
@@ -49541,19 +49548,19 @@ class SessionRecorder {
      * @param event.type The enum type of the specific event (e.g. meta, full snapshot, incremental snapshot)
      * @param event.data The specific data to describe the event, this is different depending on what the type is
      */
-    emit(event) {
-        const isMeta = event.type === EVENT_TYPES.META;
-        const isSnapshot = event.type === EVENT_TYPES.FULL_SNAPSHOT;
-        const prevLastEmitTime = this.pendo._.get(this.getLastUserInteractionEventInformation(), 'timestamp');
-        const inactivityDuration = this.pendo._.get(this.visitorConfig, 'inactivityDuration', THIRTY_MINUTES);
-        let skipUserInteractionCheck = false;
+    SessionRecorder.prototype.emit = function (event) {
+        var isMeta = event.type === EVENT_TYPES.META;
+        var isSnapshot = event.type === EVENT_TYPES.FULL_SNAPSHOT;
+        var prevLastEmitTime = this.pendo._.get(this.getLastUserInteractionEventInformation(), 'timestamp');
+        var inactivityDuration = this.pendo._.get(this.visitorConfig, 'inactivityDuration', THIRTY_MINUTES);
+        var skipUserInteractionCheck = false;
         if (event.timestamp && event.timestamp.getTime) {
             event.timestamp = event.timestamp.getTime();
         }
         if (!event.timestamp) {
             event.timestamp = (new Date()).getTime();
         }
-        const withinInactivityLimit = prevLastEmitTime && event.timestamp - prevLastEmitTime <= inactivityDuration;
+        var withinInactivityLimit = prevLastEmitTime && event.timestamp - prevLastEmitTime <= inactivityDuration;
         // If we don't have a last emit time and a META event is emitted, store the META event as the last user interaction
         // event. This most commonly happens when a replay is first started and establishes a baseline timestamp to
         // to compare inactivity against. For subsequent META events that are part of the same replay, we should have
@@ -49576,7 +49583,7 @@ class SessionRecorder {
                 this.logStopReason('INACTIVE_HIDDEN_TAB');
             }
             if (!this.isCheckingVisitorEligibility) {
-                const continuationCallback = function () {
+                var continuationCallback = function () {
                     this.send();
                     this.clearSessionInfo();
                     this.snapshot();
@@ -49612,13 +49619,13 @@ class SessionRecorder {
         }
         else if (!isMeta) {
             this.eventsSinceLastKeyFrame += 1;
-            const timeSinceLastKeyFrame = event.timestamp - this.lastKeyFrameTime;
-            const exceeds24Hours = timeSinceLastKeyFrame >= ONE_DAY_IN_MILLISECONDS;
-            const exceedsTimeFreq = timeSinceLastKeyFrame >= this.pendo._.get(this.visitorConfig, 'keyframeTimeFrequency', 30645047); // Defaults determined by BE originally, shouldn't really ever be used
-            const exceedsEventFreq = this.eventsSinceLastKeyFrame >= this.pendo._.get(this.visitorConfig, 'keyframeEventFrequency', 4548); // Defaults determined by BE originally, shouldn't really ever be used
-            const exceedsRecordingSizeLimit = this.currentRecordingSize >= this.pendo._.get(this.visitorConfig, 'recordingSizeLimit', ONE_HUNDRED_MB_IN_BYTES);
+            var timeSinceLastKeyFrame = event.timestamp - this.lastKeyFrameTime;
+            var exceeds24Hours = timeSinceLastKeyFrame >= ONE_DAY_IN_MILLISECONDS;
+            var exceedsTimeFreq = timeSinceLastKeyFrame >= this.pendo._.get(this.visitorConfig, 'keyframeTimeFrequency', 30645047); // Defaults determined by BE originally, shouldn't really ever be used
+            var exceedsEventFreq = this.eventsSinceLastKeyFrame >= this.pendo._.get(this.visitorConfig, 'keyframeEventFrequency', 4548); // Defaults determined by BE originally, shouldn't really ever be used
+            var exceedsRecordingSizeLimit = this.currentRecordingSize >= this.pendo._.get(this.visitorConfig, 'recordingSizeLimit', ONE_HUNDRED_MB_IN_BYTES);
             if (exceeds24Hours || (exceedsTimeFreq && exceedsEventFreq) || exceedsRecordingSizeLimit) {
-                const continuationCallback = function () {
+                var continuationCallback = function () {
                     this.currentRecordingSize = 0;
                     this.snapshot();
                 };
@@ -49630,18 +49637,18 @@ class SessionRecorder {
                 }
             }
         }
-    }
-    updateCurrentRecordingSize(recordingPayloadSize) {
+    };
+    SessionRecorder.prototype.updateCurrentRecordingSize = function (recordingPayloadSize) {
         this.currentRecordingSize += recordingPayloadSize;
-    }
-    onWorkerMessage(messageData) {
+    };
+    SessionRecorder.prototype.onWorkerMessage = function (messageData) {
         switch (messageData.type) {
             case 'workerDied': {
                 this.logStopReason('WORKER_DIED');
                 break;
             }
             case 'recordingPayloadSize': {
-                const { recordingPayloadSize, exceedsPayloadSizeLimit } = messageData;
+                var recordingPayloadSize = messageData.recordingPayloadSize, exceedsPayloadSizeLimit = messageData.exceedsPayloadSizeLimit;
                 if (!recordingPayloadSize)
                     return;
                 // stop recording if recording payload exceeds allowed payload size
@@ -49654,7 +49661,7 @@ class SessionRecorder {
                 break;
             }
             case 'hostedResources': {
-                const { hostedResourcesEvent } = messageData;
+                var hostedResourcesEvent = messageData.hostedResourcesEvent;
                 if (!hostedResourcesEvent)
                     return;
                 this.sendHostedResources(hostedResourcesEvent);
@@ -49665,12 +49672,12 @@ class SessionRecorder {
                 break;
             }
             case 'missingData': {
-                this.logStopReason(`MISSING_${messageData.missingData}`);
+                this.logStopReason("MISSING_".concat(messageData.missingData));
                 break;
             }
         }
-    }
-    addRecordingId(event) {
+    };
+    SessionRecorder.prototype.addRecordingId = function (event) {
         if (!this.isRecording())
             return;
         if (!this.recordingId || !event || !event.data || !event.data.length)
@@ -49689,7 +49696,7 @@ class SessionRecorder {
             return;
         }
         this._markEvents([capturedEvent]);
-    }
+    };
     /**
      * Used to stop collecting replay data.
      *
@@ -49700,7 +49707,7 @@ class SessionRecorder {
      * @example
      * pendo.recording.stop()
      */
-    stop() {
+    SessionRecorder.prototype.stop = function () {
         if (this._stop) {
             this._stop();
         }
@@ -49718,32 +49725,33 @@ class SessionRecorder {
         this.accountId = null;
         this.clearSessionInfo();
         this.onRecordingStop();
-    }
-    handleHidden() {
+    };
+    SessionRecorder.prototype.handleHidden = function () {
         this.send({ hidden: true });
-    }
-    handleUnload() {
+    };
+    SessionRecorder.prototype.handleUnload = function () {
         if (this.api.ConfigReader.get(RECORDING_CONFIG_DISABLE_UNLOAD))
             return;
         this.send({ unload: true });
-    }
-    buildRequestUrl(baseUrl, queryObj) {
+    };
+    SessionRecorder.prototype.buildRequestUrl = function (baseUrl, queryObj) {
         var authedQueryObj = this.pendo._.extend({}, this.api.agent.getJwtInfoCopy(), queryObj);
         var queryString = this.pendo._.map(authedQueryObj, function (value, key) {
-            return `${key}=${value}`;
+            return "".concat(key, "=").concat(value);
         }).join('&');
-        return queryString.length ? `${baseUrl}?${queryString}` : baseUrl;
-    }
-    sendFailure(reason) {
+        return queryString.length ? "".concat(baseUrl, "?").concat(queryString) : baseUrl;
+    };
+    SessionRecorder.prototype.sendFailure = function (reason) {
         this.stop();
         this.logStopReason(reason);
-    }
-    rateLimitExceeded() {
+    };
+    SessionRecorder.prototype.rateLimitExceeded = function () {
         this.send(); // sends first chunk of 20k
         this.stop(); // sends 2nd chunk of 20k, rest is ignored
         this.logStopReason('DATA_OVERLOAD');
-    }
-    send({ unload = false, keyframe = false, hidden = false } = {}) {
+    };
+    SessionRecorder.prototype.send = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.unload, unload = _c === void 0 ? false : _c, _d = _b.keyframe, keyframe = _d === void 0 ? false : _d, _e = _b.hidden, hidden = _e === void 0 ? false : _e;
         if (!this.isRecording())
             return;
         if (!this.buffer)
@@ -49773,7 +49781,7 @@ class SessionRecorder {
         }
         // Used to add promoted metadata onto the recording event
         this.api.Events.eventCaptured.trigger(payload);
-        const params = {
+        var params = {
             v: this.pendo.VERSION,
             recordingId: this.recordingId
         };
@@ -49784,11 +49792,11 @@ class SessionRecorder {
             params.ns = 1;
             this.isNewSession = false;
         }
-        var url = this.buildRequestUrl(`${this.pendo.HOST}/data/rec/${this.pendo.apiKey}`, params);
+        var url = this.buildRequestUrl("".concat(this.pendo.HOST, "/data/rec/").concat(this.pendo.apiKey), params);
         payload = this.buffer.pack(payload, this.pendo._);
         if (unload || hidden) {
             try {
-                this.sendQueue.drain([{ url, payload }], unload);
+                this.sendQueue.drain([{ url: url, payload: payload }], unload);
             }
             catch (e) {
                 if (e.reason) {
@@ -49800,29 +49808,30 @@ class SessionRecorder {
             }
         }
         else {
-            this.sendQueue.push({ url, payload });
+            this.sendQueue.push({ url: url, payload: payload });
         }
         if (!this.buffer.isEmpty()) {
-            this.send({ unload });
+            this.send({ unload: unload });
         }
-    }
-    fetchVisitorConfig() {
-        const jzb = this.pendo.compress({
+    };
+    SessionRecorder.prototype.fetchVisitorConfig = function () {
+        var jzb = this.pendo.compress({
             url: this.pendo.url.get(),
             metadata: this.pendo.getSerializedMetadata(),
             visitorId: this.visitorId,
             accountId: this.accountId
         });
-        const url = this.buildRequestUrl(`${this.pendo.HOST}/data/recordingconf/${this.pendo.apiKey}`, {
-            jzb,
+        var url = this.buildRequestUrl("".concat(this.pendo.HOST, "/data/recordingconf/").concat(this.pendo.apiKey), {
+            jzb: jzb,
             ct: (new Date().getTime()),
             v: this.pendo.VERSION
         });
         return fetch(url, {
             method: 'GET'
-        }).then(response => response.json());
-    }
-    logStopReason(reason, error) {
+        }).then(function (response) { return response.json(); });
+    };
+    SessionRecorder.prototype.logStopReason = function (reason, error) {
+        var _this = this;
         var tracer = this.api.EventTracer.addTracerIds({});
         var payload = this.pendo._.extend({
             type: 'recording',
@@ -49838,51 +49847,53 @@ class SessionRecorder {
             recordingPayload: [],
             sequence: 0,
             recordingPayloadCount: 0,
-            props: Object.assign({ reason }, (error && { error: error instanceof Error ? error === null || error === void 0 ? void 0 : error.message : error }))
+            props: __assign({ reason: reason }, (error && { error: error instanceof Error ? error === null || error === void 0 ? void 0 : error.message : error }))
         }, tracer);
         var jzb = this.pendo.compress(payload);
-        var url = this.buildRequestUrl(`${this.pendo.HOST}/data/rec/${this.pendo.apiKey}`, {
-            jzb,
+        var url = this.buildRequestUrl("".concat(this.pendo.HOST, "/data/rec/").concat(this.pendo.apiKey), {
+            jzb: jzb,
             ct: (new Date().getTime()),
             v: this.pendo.VERSION,
             recordingId: payload.recordingId
         });
         var body = this.pendo.compress(payload, 'binary');
         return this.transport.post(url, {
-            body,
+            body: body,
             keepalive: true
-        }).catch((e) => {
-            this.api.log.critical('Failed to send reason for stopping recording', { error: e });
+        })["catch"](function (e) {
+            _this.api.log.critical('Failed to send reason for stopping recording', { error: e });
         });
-    }
-    sendHostedResources(event) {
+    };
+    SessionRecorder.prototype.sendHostedResources = function (event) {
+        var _this = this;
         var tracer = this.api.EventTracer.addTracerIds({});
-        var payload = this.pendo._.extend(Object.assign(Object.assign({}, event), { browserTime: new Date().getTime() }), tracer);
-        var url = this.buildRequestUrl(`${this.pendo.HOST}/data/rec/${this.pendo.apiKey}`, {
+        var payload = this.pendo._.extend(__assign(__assign({}, event), { browserTime: new Date().getTime() }), tracer);
+        var url = this.buildRequestUrl("".concat(this.pendo.HOST, "/data/rec/").concat(this.pendo.apiKey), {
             ct: (new Date().getTime()),
             v: this.pendo.VERSION,
             recordingId: payload.recordingId
         });
         var body = this.pendo.compress(payload, 'binary');
         return this.transport.post(url, {
-            body,
+            body: body,
             keepalive: true
-        }).catch((e) => {
-            this.api.log.critical('Failed to send hosted resources for recording event', { error: e });
+        })["catch"](function (e) {
+            _this.api.log.critical('Failed to send hosted resources for recording event', { error: e });
         });
-    }
+    };
     /**
      * This should fire when an event is triggered in clearClonedStorage. Under normal circumstances, the event will be
      * triggered before recording begins in the cloned tab. On the off chance tabId changes again though, create a new
      * replay. We want to avoid scenarios where a single recordingId is associated with multiple tabIds. This can happen if
      * clone detection runs in a duplicated tab before it runs in the original tab.
      */
-    handleTabIdChange() {
+    SessionRecorder.prototype.handleTabIdChange = function () {
         this.send();
         this.clearSessionInfo();
         this.snapshot();
-    }
-}
+    };
+    return SessionRecorder;
+}());
 
 function wrapMethodWithCatch(method) {
     return function () {
@@ -49903,7 +49914,8 @@ function errorLogger(recorder) {
         return recorder;
     if (!recorder.constructor || !recorder.constructor.prototype)
         return recorder;
-    for (let methodName of Object.getOwnPropertyNames(recorder.constructor.prototype)) {
+    for (var _i = 0, _a = Object.getOwnPropertyNames(recorder.constructor.prototype); _i < _a.length; _i++) {
+        var methodName = _a[_i];
         if (methodName === 'constructor')
             continue;
         recorder[methodName] = wrapMethodWithCatch(recorder[methodName]);