@pendo/agent 2.330.0 → 2.330.1

package/dist/dom.esm.js

@@ -7505,7 +7505,7 @@ function applyMatrix2dRect(matrix2d, rect) {
     return transformedRect;
 }
 
-var VERSION = '2.330.0_';
+var VERSION = '2.330.1_';
 
 var decodeURIComponent = _.isFunction(window.decodeURIComponent) ? window.decodeURIComponent : _.identity;
 
@@ -7624,7 +7624,13 @@ function hasCookieDomain() {
     return !!cookieDomain;
 }
 function clearCookie(name) {
-    document.cookie = name + '=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT';
+    // Always expire the cookie rather than overwriting it with an empty value.
+    // When a cookieDomain is set the domain attribute must be included or the
+    // domain-scoped cookie can't be matched for deletion -- omitting it (or
+    // writing a blank value) leaves a permanent empty cookie that still costs
+    // request-header space via its name.
+    var cookie = name + '=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT';
+    document.cookie = cookie;
 }
 var getPendoCookieKey = function (name, cookieSuffix) {
     return "_pendo_".concat(name, ".").concat(cookieSuffix || pendo.apiKey);

package/dist/pendo.module.js

@@ -4010,8 +4010,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.330.0_';
-let PACKAGE_VERSION = '2.330.0';
+let VERSION = '2.330.1_';
+let PACKAGE_VERSION = '2.330.1';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -4587,11 +4587,16 @@ function hasCookieDomain() {
     return !!cookieDomain;
 }
 function clearCookie(name) {
-    if (hasCookieDomain()) {
-        setCookie(name, '');
-        return;
+    // Always expire the cookie rather than overwriting it with an empty value.
+    // When a cookieDomain is set the domain attribute must be included or the
+    // domain-scoped cookie can't be matched for deletion -- omitting it (or
+    // writing a blank value) leaves a permanent empty cookie that still costs
+    // request-header space via its name.
+    var cookie = name + '=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT';
+    if (cookieDomain) {
+        cookie += ';domain=' + cookieDomain;
     }
-    document.cookie = name + '=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT';
+    document.cookie = cookie;
 }
 var getPendoCookieKey = function (name, cookieSuffix) {
     return `_pendo_${name}.${cookieSuffix || pendo$1.apiKey}`;
@@ -24998,7 +25003,10 @@ var initGuides = function (observer) {
     * @access public
     * @label AD_BLOCK_STORAGE_KEY
     */
-    agentStorage.registry.addLocal(AD_BLOCK_STORAGE_KEY, { duration: 14400000 }); // 4 hours default duration
+    agentStorage.registry.addLocal(AD_BLOCK_STORAGE_KEY, {
+        duration: 14400000,
+        localStorageOnly: true
+    });
     GuideRuntime.initialize();
     registerPostrenderScripts(GuideRuntime);
     return () => {
@@ -27269,7 +27277,7 @@ function launchDesignerOrPreview(options) {
     * @access public
     * @label pendoPreview
     */
-    agentStorage.registry.addLocal(pendoPreview$1);
+    agentStorage.registry.addLocal(pendoPreview$1, { localStorageOnly: true });
     /**
     * Application state while previewing a guide from the designer. Used while designer preview is active
     * to track step, status, etc., and cleared when designer preview is exited.
@@ -27279,7 +27287,7 @@ function launchDesignerOrPreview(options) {
     * @access public
     * @label designerPreview
     */
-    agentStorage.registry.addLocal(designerPreview$1);
+    agentStorage.registry.addLocal(designerPreview$1, { localStorageOnly: true });
     // in order, try to launch:
     // 1) designer
     // 2) preview
@@ -30209,7 +30217,10 @@ function initLogging() {
     * @access public
     * @label LOG_ENABLED
     */
-    agentStorage.registry.addLocal(LOG_ENABLED, { isPlain: true });
+    agentStorage.registry.addLocal(LOG_ENABLED, {
+        isPlain: true,
+        localStorageOnly: true
+    });
     /**
     * DEPRECATED: Stores the active contexts for logging.
     *
@@ -30218,7 +30229,10 @@ function initLogging() {
     * @access private
     * @label ACTIVE_CONTEXTS
     */
-    agentStorage.registry.addLocal(ACTIVE_CONTEXTS, { isPlain: true });
+    agentStorage.registry.addLocal(ACTIVE_CONTEXTS, {
+        isPlain: true,
+        localStorageOnly: true
+    });
 }
 var createContexts = function (contexts, args) {
     return _.compact([].concat(contexts, args));
@@ -39414,7 +39428,10 @@ var initLauncherPlugin = function (pendo, PluginAPI) {
     * @access public
     * @label LAUNCHER_CLOSED
     */
-    PluginAPI.agentStorage.registry.addLocal(LAUNCHER_CLOSED, { duration: 10 * 24 * 60 * 60 * 1000 }); // 10 days default duration
+    PluginAPI.agentStorage.registry.addLocal(LAUNCHER_CLOSED, {
+        duration: 10 * 24 * 60 * 60 * 1000,
+        localStorageOnly: true
+    });
 };
 var teardownLauncherPlugin = function (pendo, PluginAPI) {
     deregisterLoadGuideJobs(loadLauncherContentHandler);
@@ -41017,7 +41034,12 @@ function initAgent(pendo, PendoConfig) {
         * @access public
         * @label debugEnabled
         */
-    agentStorage.registry.addLocal(debugEnabled, { isPlain: true, serializer: JSON.stringify, deserializer: SafeJsonDeserializer });
+    agentStorage.registry.addLocal(debugEnabled, {
+        isPlain: true,
+        serializer: JSON.stringify,
+        deserializer: SafeJsonDeserializer,
+        localStorageOnly: true
+    });
     setPendoConfig(PendoConfig);
     overwriteBuiltConfigWithPendoConfig();
     if (!loadAsModule(PendoConfig) && loadAlternateAgent(PendoConfig, pendo, isDebuggingEnabled()))
@@ -43134,7 +43156,7 @@ function Feedback() {
         * @access public
         * @label notificationCountCookie
         */
-        PluginAPI.agentStorage.registry.addLocal(notificationCountCookie);
+        PluginAPI.agentStorage.registry.addLocal(notificationCountCookie, { localStorageOnly: true });
         /**
         * Stores the last ping time for the legacy Feedback widget. Used to control the
         * frequency of communication with the Feedback server.
@@ -43144,7 +43166,10 @@ function Feedback() {
         * @access public
         * @label PING_COOKIE
         */
-        PluginAPI.agentStorage.registry.addLocal(PING_COOKIE, { duration: PING_COOKIE_EXPIRATION });
+        PluginAPI.agentStorage.registry.addLocal(PING_COOKIE, {
+            duration: PING_COOKIE_EXPIRATION,
+            localStorageOnly: true
+        });
         return {
             validate
         };
@@ -49299,32 +49324,31 @@ var n;
 }(n || (n = {}));
   return record; }
 
-var SessionRecorderBuffer = /** @class */ (function () {
-    function SessionRecorderBuffer(interval, maxCount) {
-        if (maxCount === void 0) { maxCount = Infinity; }
+class SessionRecorderBuffer {
+    constructor(interval, maxCount = Infinity) {
         this.data = [];
         this.sequenceNumber = 0;
         this.interval = interval;
         this.maxCount = maxCount;
         this.doubledMaxCount = maxCount * 2;
     }
-    SessionRecorderBuffer.prototype.isEmpty = function () {
+    isEmpty() {
         return this.data.length === 0;
-    };
-    SessionRecorderBuffer.prototype.count = function () {
+    }
+    count() {
         return this.data.length;
-    };
-    SessionRecorderBuffer.prototype.clear = function () {
+    }
+    clear() {
         this.data.length = 0;
-    };
-    SessionRecorderBuffer.prototype.clearSequence = function () {
+    }
+    clearSequence() {
         this.sequenceNumber = 0;
-    };
-    SessionRecorderBuffer.prototype.push = function (event) {
+    }
+    push(event) {
         this.data.push(event);
         this.checkRateLimit();
-    };
-    SessionRecorderBuffer.prototype.pack = function (envelope, _) {
+    }
+    pack(envelope, _) {
         var eventsToSend = this.data.splice(0, this.maxCount);
         envelope.recordingPayload = eventsToSend;
         envelope.sequence = this.sequenceNumber;
@@ -49332,8 +49356,8 @@ var SessionRecorderBuffer = /** @class */ (function () {
         if (eventsToSend.length) {
             envelope.browserTime = eventsToSend[0].timestamp;
         }
-        envelope.recordingPayloadMetadata = _.map(eventsToSend, function (event) {
-            var metadata = _.pick(event, 'type', 'timestamp');
+        envelope.recordingPayloadMetadata = _.map(eventsToSend, event => {
+            const metadata = _.pick(event, 'type', 'timestamp');
             if (event.data) {
                 metadata.data = _.pick(event.data, 'source', 'type', 'x', 'y', 'id', 'height', 'width', 'href');
             }
@@ -49341,18 +49365,17 @@ var SessionRecorderBuffer = /** @class */ (function () {
         });
         this.sequenceNumber += eventsToSend.length;
         return envelope;
-    };
-    SessionRecorderBuffer.prototype.checkRateLimit = function () {
-        var length = this.data.length;
+    }
+    checkRateLimit() {
+        const 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;
+            const elapsed = this.data[length - 1].timestamp - this.data[length - this.doubledMaxCount].timestamp;
             if (elapsed <= this.interval && this.onRateLimit) {
                 this.onRateLimit();
             }
         }
-    };
-    return SessionRecorderBuffer;
-}());
+    }
+}
 
 function __rest(s, e) {
     var t = {};
@@ -49376,52 +49399,24 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var RECORDING_CONFIG_WORKERURL$1 = 'recording.workerUrl';
-var MAX_SIZE = 2000000;
-var RESOURCE_CACHING$1 = 'resourceCaching';
-var Transport = /** @class */ (function () {
-    function Transport(WorkerClass, pendo, api) {
+const RECORDING_CONFIG_WORKERURL$1 = 'recording.workerUrl';
+const MAX_SIZE = 2000000;
+const RESOURCE_CACHING$1 = 'resourceCaching';
+class Transport {
+    constructor(WorkerClass, pendo, api) {
         this.WorkerClass = WorkerClass;
         this.pendo = pendo;
         this.api = api;
         this.maxSize = MAX_SIZE;
-        this.lockID = "worker-lock-".concat(this.pendo.randomString(16));
+        this.lockID = `worker-lock-${this.pendo.randomString(16)}`;
         this.isResourceCachingEnabled = this.api.ConfigReader.get(RESOURCE_CACHING$1);
     }
-    Transport.prototype.start = function (config) {
+    start(config) {
         if (config.disableWorker)
             return;
         if (!this.worker) {
@@ -49431,7 +49426,7 @@ var Transport = /** @class */ (function () {
                     this.worker = config.workerOverride;
                 }
                 else {
-                    var workerUrl = this.api.ConfigReader.get(RECORDING_CONFIG_WORKERURL$1);
+                    const workerUrl = this.api.ConfigReader.get(RECORDING_CONFIG_WORKERURL$1);
                     this.usesSelfHostedWorker = workerUrl != null;
                     this.worker = workerUrl ? new Worker(workerUrl) : new this.WorkerClass();
                 }
@@ -49445,35 +49440,34 @@ var Transport = /** @class */ (function () {
                 this.worker = null;
             }
         }
-    };
-    Transport.prototype.stop = function () {
+    }
+    stop() {
         if (this.worker) {
             this.worker.terminate();
             delete this.worker;
         }
-    };
-    Transport.prototype.send = function (envelope, isUnload, failureCount) {
-        if (failureCount === void 0) { failureCount = 0; }
-        var url = envelope.url;
-        var payload = envelope.payload;
+    }
+    send(envelope, isUnload, failureCount = 0) {
+        let { url } = envelope;
+        const { payload } = envelope;
         if (failureCount > 0) {
-            url = "".concat(url, "&rt=").concat(failureCount);
+            url = `${url}&rt=${failureCount}`;
         }
         if (this.worker && !isUnload && payload) {
-            var deferred_1 = {};
-            deferred_1.promise = new Promise$2(function (resolve, reject) {
-                deferred_1.resolve = resolve;
-                deferred_1.reject = reject;
+            const deferred = {};
+            deferred.promise = new Promise$2((resolve, reject) => {
+                deferred.resolve = resolve;
+                deferred.reject = reject;
             });
-            this.workerResponse = deferred_1;
-            this.worker.postMessage({ url: url, payload: payload, shouldCacheResources: this.isResourceCachingEnabled });
-            return deferred_1.promise;
+            this.workerResponse = deferred;
+            this.worker.postMessage({ url, payload, shouldCacheResources: this.isResourceCachingEnabled });
+            return deferred.promise;
         }
         else {
             if (!envelope.body) {
-                var strPayload = JSON.stringify(payload);
+                const strPayload = JSON.stringify(payload);
                 if (strPayload.length > this.maxSize) {
-                    var error = new Error('maximum recording payload size exceeded');
+                    const error = new Error('maximum recording payload size exceeded');
                     error.reason = 'HEAVY_EVENT';
                     error.context = {
                         size: strPayload.length,
@@ -49484,14 +49478,14 @@ var Transport = /** @class */ (function () {
                 envelope.body = this.pendo.compress(strPayload, 'binary');
                 delete envelope.payload;
             }
-            url = "".concat(url, "&ct=").concat(new Date().getTime());
+            url = `${url}&ct=${new Date().getTime()}`;
             return this.post(url, {
                 keepalive: isUnload,
                 body: envelope.body
             });
         }
-    };
-    Transport.prototype.post = function (url, options) {
+    }
+    post(url, options) {
         options.method = 'POST';
         if (options.keepalive && this.api.transmit.fetchKeepalive.supported()) {
             return this.api.transmit.fetchKeepalive(url, options);
@@ -49503,57 +49497,46 @@ var Transport = /** @class */ (function () {
         else {
             return this.pendo.ajax.post(url, options.body);
         }
-    };
-    Transport.prototype._onMessage = function (messageEvent) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(messageEvent.data && messageEvent.data.ready && navigator.locks)) return [3 /*break*/, 2];
-                        // When the lock is released, we can assume the worker was terminated or closed
-                        return [4 /*yield*/, navigator.locks.request(this.lockID, function () { })];
-                    case 1:
-                        // When the lock is released, we can assume the worker was terminated or closed
-                        _a.sent();
-                        this.onWorkerMessage({ type: 'workerDied' });
-                        _a.label = 2;
-                    case 2:
-                        // handle non-POST request responses from worker
-                        if (messageEvent.data && messageEvent.data.type) {
-                            this.onWorkerMessage(messageEvent.data);
-                            return [2 /*return*/];
-                        }
-                        // handle POST request response from worker
-                        if (messageEvent.data && messageEvent.data.error) {
-                            if ((messageEvent.data.status && messageEvent.data.status < 500) ||
-                                messageEvent.data.sequence == null) {
-                                this.api.log.critical('Failed to send recording data from web worker', { error: messageEvent.data.error });
-                            }
-                            if (this.workerResponse) {
-                                this.workerResponse.reject();
-                                this.workerResponse = null;
-                            }
-                        }
-                        if (this.workerResponse) {
-                            this.workerResponse.resolve();
-                            this.workerResponse = null;
-                        }
-                        return [2 /*return*/];
+    }
+    _onMessage(messageEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (messageEvent.data && messageEvent.data.ready && navigator.locks) {
+                // When the lock is released, we can assume the worker was terminated or closed
+                yield navigator.locks.request(this.lockID, () => { });
+                this.onWorkerMessage({ type: 'workerDied' });
+            }
+            // handle non-POST request responses from worker
+            if (messageEvent.data && messageEvent.data.type) {
+                this.onWorkerMessage(messageEvent.data);
+                return;
+            }
+            // handle POST request response from worker
+            if (messageEvent.data && messageEvent.data.error) {
+                if ((messageEvent.data.status && messageEvent.data.status < 500) ||
+                    messageEvent.data.sequence == null) {
+                    this.api.log.critical('Failed to send recording data from web worker', { error: messageEvent.data.error });
                 }
-            });
+                if (this.workerResponse) {
+                    this.workerResponse.reject();
+                    this.workerResponse = null;
+                }
+            }
+            if (this.workerResponse) {
+                this.workerResponse.resolve();
+                this.workerResponse = null;
+            }
         });
-    };
-    Transport.prototype._onError = function () {
+    }
+    _onError() {
         if (this.onError) {
             this.onError();
         }
-    };
-    return Transport;
-}());
+    }
+}
 
-var ELEMENT_NODE = 1;
-var INPUT_MASK = '*'.repeat(10);
-var NUMBER_INPUT_MASK = '0'.repeat(10);
+const ELEMENT_NODE = 1;
+const INPUT_MASK = '*'.repeat(10);
+const NUMBER_INPUT_MASK = '0'.repeat(10);
 function isElementNode(node) {
     if (!node)
         return false;
@@ -49562,12 +49545,10 @@ function isElementNode(node) {
     return true;
 }
 function getParent(elem) {
-    var isElementShadowRoot = typeof window.ShadowRoot !== 'undefined' && elem instanceof window.ShadowRoot && elem.host;
+    const isElementShadowRoot = typeof window.ShadowRoot !== 'undefined' && elem instanceof window.ShadowRoot && elem.host;
     return isElementShadowRoot ? elem.host : elem.parentNode;
 }
-function distanceToMatch(node, selector, limit, distance) {
-    if (limit === void 0) { limit = Infinity; }
-    if (distance === void 0) { distance = 0; }
+function distanceToMatch(node, selector, limit = Infinity, distance = 0) {
     if (distance > limit)
         return -1;
     if (!node)
@@ -49581,15 +49562,15 @@ function distanceToMatch(node, selector, limit, distance) {
     return distanceToMatch(getParent(node), selector, limit, distance + 1);
 }
 function shouldMask(node, options) {
-    var maskAllText = options.maskAllText, maskTextSelector = options.maskTextSelector, unmaskTextSelector = options.unmaskTextSelector;
+    const { maskAllText, maskTextSelector, unmaskTextSelector } = options;
     try {
-        var el = isElementNode(node) ? node : node.parentElement;
+        const el = isElementNode(node) ? node : node.parentElement;
         if (el === null)
             return false;
         if ((el.tagName || '').toUpperCase() === 'STYLE')
             return false;
-        var maskDistance = -1;
-        var unmaskDistance = -1;
+        let maskDistance = -1;
+        let unmaskDistance = -1;
         if (maskAllText) {
             unmaskDistance = distanceToMatch(el, unmaskTextSelector);
             if (unmaskDistance < 0) {
@@ -49622,8 +49603,8 @@ function isNumberInput(element) {
 }
 function shouldMaskInput(element, maskInputOptions) {
     if (maskInputOptions && isElementNode(element)) {
-        var tagName = (element.tagName || '').toLowerCase();
-        var type = (element.type || '').toLowerCase();
+        const tagName = (element.tagName || '').toLowerCase();
+        const type = (element.type || '').toLowerCase();
         if (maskInputOptions[tagName] || maskInputOptions[type]) {
             return true;
         }
@@ -51117,12 +51098,12 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
         }
     }
 
-    var ONE_HUNDRED_MB_IN_BYTES = 100 * 1024 * 1024;
+    const ONE_HUNDRED_MB_IN_BYTES = 100 * 1024 * 1024;
     function matchHostedResources(recordingEvent, stringifiedRecordingPayload) {
-        var fontURLRegex = /https:\/\/[^"\\\s]+?\.(woff2?|ttf|otf|eot)(\?[^"\\\s]*)?\b/g;
-        var matches = stringifiedRecordingPayload.match(fontURLRegex);
+        const fontURLRegex = /https:\/\/[^"\\\s]+?\.(woff2?|ttf|otf|eot)(\?[^"\\\s]*)?\b/g;
+        const matches = stringifiedRecordingPayload.match(fontURLRegex);
         // de-duplicate matches
-        var hostedResources = matches ? Array.from(new Set(matches)) : [];
+        const hostedResources = matches ? Array.from(new Set(matches)) : [];
         return {
             type: 'recording',
             visitorId: recordingEvent.visitorId,
@@ -51137,7 +51118,7 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
             recordingPayloadMetadata: [],
             sequence: 0,
             recordingPayloadCount: 0,
-            hostedResources: hostedResources
+            hostedResources
         };
     }
     // keep in mind changes here may need addressing in the extension worker proxy as well
@@ -51145,69 +51126,69 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
         try {
             if (e.data.type === 'init' && e.data.lockID) {
                 if (navigator.locks) {
-                    navigator.locks.request(e.data.lockID, function () {
+                    navigator.locks.request(e.data.lockID, () => {
                         postMessage({ ready: true });
                         // This unresolved promise keeps the lock held with the worker until the worker is
                         // terminated at which point the lock is released.
-                        return new Promise$2(function () { });
+                        return new Promise$2(() => { });
                     });
                 }
                 return;
             }
             if (e.data.url && e.data.payload) {
-                var _a = e.data, url = _a.url, payload = _a.payload, shouldCacheResources = _a.shouldCacheResources;
+                let { url, payload, shouldCacheResources } = e.data;
                 if (Object.keys(payload).length === 0) {
                     postMessage({
                         type: 'emptyPayload'
                     });
                 }
-                var sequence_1 = payload.sequence;
-                var stringifiedRecordingPayload = JSON.stringify(payload.recordingPayload);
+                const { sequence } = payload;
+                const stringifiedRecordingPayload = JSON.stringify(payload.recordingPayload);
                 // calculate and post back the recording payload size before the payload is compressed
-                var recordingPayloadSize = new TextEncoder().encode(stringifiedRecordingPayload).length;
-                var exceedsPayloadSizeLimit = recordingPayloadSize >= ONE_HUNDRED_MB_IN_BYTES;
+                const recordingPayloadSize = new TextEncoder().encode(stringifiedRecordingPayload).length;
+                const exceedsPayloadSizeLimit = recordingPayloadSize >= ONE_HUNDRED_MB_IN_BYTES;
                 postMessage({
                     type: 'recordingPayloadSize',
-                    recordingPayloadSize: recordingPayloadSize,
-                    exceedsPayloadSizeLimit: exceedsPayloadSizeLimit
+                    recordingPayloadSize,
+                    exceedsPayloadSizeLimit
                 });
                 // don't attempt to send the payload if it exceeds the allowed limit
                 if (exceedsPayloadSizeLimit)
                     return;
                 if (shouldCacheResources) {
-                    var hostedResourcesEvent = matchHostedResources(payload, stringifiedRecordingPayload);
+                    const hostedResourcesEvent = matchHostedResources(payload, stringifiedRecordingPayload);
                     if (hostedResourcesEvent.hostedResources.length) {
                         postMessage({
                             type: 'hostedResources',
-                            hostedResourcesEvent: hostedResourcesEvent
+                            hostedResourcesEvent
                         });
                     }
                 }
                 payload.recordingSize = recordingPayloadSize;
-                var body = compress(payload, 'binary');
+                const body = compress(payload, 'binary');
                 // we want to calculate ct (current time) as close as we can to the actual POST request
                 // so that it's as accurate as possible
-                url = "".concat(url, "&ct=").concat(new Date().getTime());
+                url = `${url}&ct=${new Date().getTime()}`;
                 fetch(url, {
                     method: 'POST',
-                    body: body
+                    body
                 }).then(function (response) {
                     if (response.status < 200 || response.status >= 300) {
                         postMessage({
-                            error: new Error("received status code ".concat(response.status, ": ").concat(response.statusText)),
+                            error: new Error(`received status code ${response.status}: ${response.statusText}`),
                             status: response.status,
-                            sequence: sequence_1
+                            sequence
                         });
                     }
                     else {
                         postMessage({
-                            sequence: sequence_1
+                            sequence
                         });
                     }
-                })["catch"](function (e) {
+                }).catch(function (e) {
                     postMessage({
                         error: e,
-                        sequence: sequence_1
+                        sequence
                     });
                 });
             }