@newrelic/browser-agent 1.234.0 → 1.235.0

package/src/common/url/canonicalize-url.test.js

@@ -1,34 +1,45 @@
+import { faker } from '@faker-js/faker'
+import * as globalScopeModule from '../util/global-scope'
+import * as cleanUrlModule from './clean-url'
+import { canonicalizeUrl } from './canonicalize-url'
+
+jest.mock('../util/global-scope')
+jest.mock('./clean-url')
+
+beforeEach(() => {
+  jest.spyOn(cleanUrlModule, 'cleanURL').mockImplementation(input => input)
+  jest.replaceProperty(globalScopeModule, 'initialLocation', faker.internet.url())
+})
+
 afterEach(() => {
-  jest.resetModules()
+  jest.resetAllMocks()
 })
 
 test.each([null, undefined, 34])('returns empty string when url argument is %s', async (url) => {
-  const { canonicalizeUrl } = await import('./canonicalize-url')
   expect(canonicalizeUrl(url)).toEqual('')
 })
 
-test('strips URLs of query strings and fragments', async () => {
-  jest.doMock('../util/global-scope', () => ({
-    initialLocation: 'http://different-domain.com/'
-  }))
-  const { canonicalizeUrl } = await import('./canonicalize-url')
-  expect(canonicalizeUrl('http://example.com/path?query=string#fragment')).toBe('http://example.com/path')
-  expect(canonicalizeUrl('https://www.example.com/path/to/file.html?param=value')).toBe('https://www.example.com/path/to/file.html')
-  expect(canonicalizeUrl('https://www.example.com/?param=value#fragment')).toBe('https://www.example.com/')
+test('uses cleanURL to clean the input and initial location URLs', () => {
+  const url = faker.internet.url()
+  canonicalizeUrl(url)
+
+  expect(cleanUrlModule.cleanURL).toHaveBeenCalledWith(globalScopeModule.initialLocation)
+  expect(cleanUrlModule.cleanURL).toHaveBeenCalledWith(url)
+  expect(cleanUrlModule.cleanURL).toHaveBeenCalledTimes(2)
 })
 
-test('returns <inline> when matching the page URL of the loader', async () => {
-  jest.doMock('../util/global-scope', () => ({
-    initialLocation: 'http://example.com/'
-  }))
-  const { canonicalizeUrl } = await import('./canonicalize-url')
-  expect(canonicalizeUrl('http://example.com/')).toEqual('<inline>')
+test('returns <inline> when input and initial page urls are the same', async () => {
+  expect(canonicalizeUrl(globalScopeModule.initialLocation)).toEqual('<inline>')
+})
+
+test('returns input url when it does not match initial page url', async () => {
+  const url = faker.internet.url()
+
+  expect(canonicalizeUrl(url)).toEqual(url)
 })
 
 test('does not identify sub-paths of the loader origin as <inline>', async () => {
-  jest.doMock('../util/global-scope', () => ({
-    initialLocation: 'http://example.com/'
-  }))
-  const { canonicalizeUrl } = await import('./canonicalize-url')
-  expect(canonicalizeUrl('http://example.com/path/to/script.js')).not.toEqual('<inline>')
+  const url = globalScopeModule.initialLocation + '/path/to/script.js'
+
+  expect(canonicalizeUrl(url)).not.toEqual('<inline>')
 })

package/src/common/util/data-size.test.js

@@ -1,24 +1,29 @@
+import { faker } from '@faker-js/faker'
+import * as stringifyModule from './stringify'
 import { dataSize } from './data-size'
 
+jest.mock('./stringify')
+
 describe('dataSize', () => {
   test('returns length of string', () => {
-    const str = 'Hello, world!'
+    const str = faker.lorem.sentence()
     expect(dataSize(str)).toBe(str.length)
   })
 
   test('returns undefined for non-object, number, or empty string', () => {
     expect(dataSize(Infinity)).toBeUndefined()
-    expect(dataSize(12345)).toBeUndefined() // might not actually be by design, but this is how it works today
+    expect(dataSize(NaN)).toBeUndefined()
+    expect(dataSize(12345)).toBeUndefined()
     expect(dataSize('')).toBeUndefined()
   })
 
   test('returns byte length of ArrayBuffer object', () => {
-    const buffer = new ArrayBuffer(8)
-    expect(dataSize(buffer)).toBe(8)
+    const buffer = new ArrayBuffer(faker.datatype.number({ min: 10, max: 100 }))
+    expect(dataSize(buffer)).toBe(buffer.byteLength)
   })
 
   test('returns size of Blob object', () => {
-    const blob = new Blob(['Hello, world!'], { type: 'text/plain' })
+    const blob = new Blob([faker.lorem.sentence()], { type: 'text/plain' })
     expect(dataSize(blob)).toBe(blob.size)
   })
 
@@ -27,24 +32,26 @@ describe('dataSize', () => {
     expect(dataSize(formData)).toBeUndefined()
   })
 
-  test('returns length of JSON string representation of object', () => {
-    const obj = {
-      str: 'Hello, world!',
-      num: 12345,
-      nestedObj: {
-        arr: [1, 2, 3]
-      }
+  test('uses stringify to get the length of an object', () => {
+    const input = {
+      [faker.datatype.uuid()]: faker.lorem.sentence()
     }
-    const expectedSize = JSON.stringify(obj).length
-    expect(dataSize(obj)).toBe(expectedSize)
+    const expectedSize = faker.datatype.number({ min: 1000, max: 10000 })
+
+    jest.spyOn(stringifyModule, 'stringify').mockReturnValue({ length: expectedSize })
+
+    expect(dataSize(input)).toBe(expectedSize)
   })
 
-  test('returns undefined for object with toJSON method that throws an error', () => {
-    const obj = {
-      toJSON: () => {
-        throw new Error('Error in toJSON')
-      }
+  test('should not throw an exception if stringify throws an exception', () => {
+    const input = {
+      [faker.datatype.uuid()]: faker.lorem.sentence()
     }
-    expect(dataSize(obj)).toBeUndefined()
+    const expectedSize = faker.datatype.number({ min: 1000, max: 10000 })
+
+    jest.spyOn(stringifyModule, 'stringify').mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
+
+    expect(() => dataSize(input)).not.toThrow()
+    expect(dataSize(input)).toBeUndefined()
   })
 })

package/src/common/util/feature-flags.js

@@ -2,7 +2,6 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { mapOwn } from './map-own'
 import { ee } from '../event-emitter/contextual-ee'
 import { handle } from '../event-emitter/handle'
 import { drain } from '../drain/drain'
@@ -13,24 +12,37 @@ const bucketMap = {
   err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
   ins: [FEATURE_NAMES.pageAction],
   spa: [FEATURE_NAMES.spa],
-  sr: [FEATURE_NAMES.sessionReplay]
+  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
 }
 
+/** Note that this function only processes each unique flag ONCE, with the first occurrence of each flag and numeric value determining its switch on/off setting. */
 export function activateFeatures (flags, agentIdentifier) {
-  var sharedEE = ee.get(agentIdentifier)
+  const sharedEE = ee.get(agentIdentifier)
   if (!(flags && typeof flags === 'object')) return
-  mapOwn(flags, function (flag, val) {
-    if (!val) {
-      return (bucketMap[flag] || []).forEach(feat => {
-        handle('block-' + flag, [], undefined, feat, sharedEE)
+
+  Object.entries(flags).forEach(([flag, num]) => {
+    if (activatedFeatures[flag] !== undefined) return
+
+    if (bucketMap[flag]) {
+      bucketMap[flag].forEach(feat => {
+        if (!num) handle('block-' + flag, [], undefined, feat, sharedEE)
+        else handle('feat-' + flag, [], undefined, feat, sharedEE)
+
+        handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE) // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
       })
-    }
+    } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE) // not sure what other flags are overlooked, but there's a test for ones not in the map --
+    // ^^^ THIS DOESN'T ACTUALLY DO ANYTHHING AS UNDEFINED/FEATURE GROUP ISN'T DRAINED
+
+    activatedFeatures[flag] = Boolean(num)
+  })
 
-    if (activatedFeatures[flag]) {
-      return
+  // Let the features waiting on their respective flags know that RUM response was received and that any missing flags are interpreted as bad entitlement / "off".
+  // Hence, those features will not be hanging forever if their flags aren't included in the response.
+  Object.keys(bucketMap).forEach(flag => {
+    if (activatedFeatures[flag] === undefined) {
+      bucketMap[flag]?.forEach(feat => handle('rumresp-' + flag, [false], undefined, feat, sharedEE))
+      activatedFeatures[flag] = false
     }
-    handle('feat-' + flag, [], undefined, bucketMap[flag], sharedEE)
-    activatedFeatures[flag] = true
   })
   drain(agentIdentifier, FEATURE_NAMES.pageViewEvent)
 }

package/src/common/util/feature-flags.test.js

@@ -0,0 +1,98 @@
+import { faker } from '@faker-js/faker'
+import * as eventEmitterModule from '../event-emitter/contextual-ee'
+import * as handleModule from '../event-emitter/handle'
+import * as drainModule from '../drain/drain'
+import { activateFeatures, activatedFeatures } from './feature-flags'
+import { FEATURE_NAMES } from '../../loaders/features/features'
+
+jest.mock('../event-emitter/handle')
+jest.mock('../drain/drain')
+jest.mock('../event-emitter/contextual-ee', () => ({
+  __esModule: true,
+  ee: {
+    get: jest.fn(() => ({
+      foo: `bar_${Math.random()}`
+    }))
+  }
+}))
+
+let agentIdentifier
+
+beforeEach(() => {
+  agentIdentifier = faker.datatype.uuid()
+})
+
+afterEach(() => {
+  Object.keys(activatedFeatures)
+    .forEach(key => delete activatedFeatures[key])
+})
+
+test.each([
+  null,
+  undefined
+])('should not do anything when flags is %s', (input) => {
+  activateFeatures(input, agentIdentifier)
+
+  expect(handleModule.handle).not.toHaveBeenCalled()
+  expect(drainModule.drain).not.toHaveBeenCalled()
+  expect(activatedFeatures).toEqual({})
+})
+
+const bucketMap = {
+  stn: [FEATURE_NAMES.sessionTrace],
+  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
+  ins: [FEATURE_NAMES.pageAction],
+  spa: [FEATURE_NAMES.spa],
+  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
+}
+
+test('emits the right events when feature flag = 1', () => {
+  const flags = {}
+  Object.keys(bucketMap).forEach(flag => flags[flag] = 1)
+  activateFeatures(flags, agentIdentifier)
+
+  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
+
+  // each flag gets emitted to each of its mapped features, and a feat- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
+  expect(handleModule.handle).toHaveBeenCalledTimes(14)
+  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
+  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [true], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
+  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event')
+
+  Object.keys(flags).forEach(flag => flags[flag] = true)
+  expect(activatedFeatures).toEqual(flags)
+})
+
+test('emits the right events when feature flag = 0', () => {
+  const flags = {}
+  Object.keys(bucketMap).forEach(flag => flags[flag] = 0)
+  activateFeatures(flags, agentIdentifier)
+
+  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
+
+  // each flag gets emitted to each of its mapped features, and a block- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
+  expect(handleModule.handle).toHaveBeenCalledTimes(14)
+  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'block-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
+  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [false], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
+  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event')
+
+  Object.keys(flags).forEach(flag => flags[flag] = false)
+  expect(activatedFeatures).toEqual(flags)
+})
+
+test('only the first activate of the same feature is respected', () => {
+  const flags = { stn: 1 }
+  activateFeatures(flags, agentIdentifier)
+  flags.stn = 0
+  activateFeatures(flags, agentIdentifier)
+
+  const sharedEE1 = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
+  const sharedEE2 = jest.mocked(eventEmitterModule.ee.get).mock.results[1].value
+
+  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE1)
+  expect(handleModule.handle).toHaveBeenNthCalledWith(2, 'rumresp-stn', [true], undefined, 'session_trace', sharedEE1)
+  expect(handleModule.handle).not.toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE2)
+  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event')
+  expect(drainModule.drain).toHaveBeenCalledTimes(2)
+  expect(activatedFeatures.stn).toBeTruthy()
+})

package/src/common/util/global-scope.js

@@ -21,29 +21,3 @@ export let globalScope = (() => {
 })()
 
 export const initialLocation = '' + globalScope.location
-
-/**
- * The below methods are only used for testing and should be removed once the
- * reliant tests are moved to Jest.
- * tests/browser/protocol.browser.js
- * tests/browser/obfuscate.browser.js
- */
-export function setScope (obj) {
-  globalScope = { ...obj }
-}
-export function resetScope () {
-  if (isBrowserScope) {
-    globalScope = window
-  } else if (isWorkerScope) {
-    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
-      globalScope = globalThis
-    } else if (self instanceof WorkerGlobalScope) {
-      globalScope = self
-    }
-  } else {
-    throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".')
-  }
-}
-export function getGlobalScope () {
-  return globalScope
-}

package/src/common/util/global-scope.test.js

@@ -0,0 +1,87 @@
+/*
+The global-scope module contains exports that are defined once at the time
+of importing the module. For this reason, the module must be dynamically
+imported in each test case.
+
+A scope must always exist or importing the module will throw an error. Use
+`enableWorkerScope` to enable the worker scope. Be sure to call `disableWorkerScope`
+before any calls to `expect` or the test will fail with an error from Jest.
+*/
+
+import { faker } from '@faker-js/faker'
+
+afterEach(() => {
+  jest.restoreAllMocks()
+  jest.resetModules()
+})
+
+test('should indicate a browser scope', async () => {
+  jest.spyOn(global, 'window', 'get').mockReturnValue({ document: {} })
+
+  const globalScopeModule = await import('./global-scope')
+
+  expect(globalScopeModule.isBrowserScope).toBe(true)
+  expect(globalScopeModule.isWorkerScope).toBe(false)
+  expect(globalScopeModule.globalScope).toBe(global.window)
+})
+
+test('should indicate a worker scope', async () => {
+  enableWorkerScope()
+  const globalScopeModule = await import('./global-scope')
+  const mockedGlobalThis = global.globalThis
+  disableWorkerScope()
+
+  expect(globalScopeModule.isBrowserScope).toBe(false)
+  expect(globalScopeModule.isWorkerScope).toBe(true)
+  expect(globalScopeModule.globalScope).toBe(mockedGlobalThis)
+})
+
+test('should return the self global', async () => {
+  enableWorkerScope()
+  jest.replaceProperty(global, 'globalThis', null)
+  jest.spyOn(global, 'self', 'get').mockReturnValue(new global.WorkerGlobalScope())
+
+  const globalScopeModule = await import('./global-scope')
+  const mockedGlobalSelf = global.self
+  disableWorkerScope()
+
+  expect(globalScopeModule.isBrowserScope).toBe(false)
+  expect(globalScopeModule.isWorkerScope).toBe(true)
+  expect(globalScopeModule.globalScope).toBe(mockedGlobalSelf)
+})
+
+test('should throw an error when a scope cannot be defined', async () => {
+  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined)
+
+  await expect(() => import('./global-scope')).rejects.toThrow()
+})
+
+test('should immediately store the current location', async () => {
+  const url = faker.internet.url()
+  jest.spyOn(window, 'location', 'get').mockReturnValue(url)
+
+  const globalScopeModule = await import('./global-scope')
+
+  expect(globalScopeModule.initialLocation).toBe(url)
+})
+
+function enableWorkerScope () {
+  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined)
+
+  class WorkerNavigator {}
+  class WorkerGlobalScope {
+    navigator = new WorkerNavigator()
+  }
+  global.WorkerGlobalScope = WorkerGlobalScope
+  global.WorkerNavigator = WorkerNavigator
+
+  jest.spyOn(global, 'navigator', 'get').mockReturnValue(new global.WorkerNavigator())
+  jest.replaceProperty(global, 'globalThis', new WorkerGlobalScope())
+}
+
+function disableWorkerScope () {
+  delete global.WorkerGlobalScope
+  delete global.WorkerNavigator
+
+  jest.restoreAllMocks()
+}

package/src/common/util/obfuscate.component-test.js

@@ -0,0 +1,173 @@
+import { faker } from '@faker-js/faker'
+import * as configModule from '../config/config'
+import * as urlProtocolModule from '../url/protocol'
+import * as consolModule from './console'
+import * as obfuscateModule from './obfuscate'
+
+jest.mock('../config/config')
+jest.mock('../context/shared-context')
+jest.mock('../url/protocol')
+jest.mock('./console')
+
+let agentIdentifier
+const rules = [{
+  regex: /pii/g,
+  replacement: 'OBFUSCATED'
+}]
+
+beforeEach(() => {
+  agentIdentifier = faker.datatype.uuid()
+})
+
+afterEach(() => {
+  jest.resetAllMocks()
+})
+
+describe('Obfuscator', () => {
+  test('shouldObfuscate returns true when there are rules', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
+
+    const obfuscator = new obfuscateModule.Obfuscator()
+    obfuscator.sharedContext = { agentIdentifier }
+
+    expect(obfuscator.shouldObfuscate()).toEqual(true)
+  })
+
+  test('shouldObfuscate returns false when there are no rules', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue([])
+
+    const obfuscator = new obfuscateModule.Obfuscator()
+    obfuscator.sharedContext = { agentIdentifier }
+
+    expect(obfuscator.shouldObfuscate()).toEqual(false)
+  })
+
+  test('obfuscateString returns the input when there are no rules', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue([])
+
+    const input = faker.lorem.sentence()
+    const obfuscator = new obfuscateModule.Obfuscator()
+    obfuscator.sharedContext = { agentIdentifier }
+
+    expect(obfuscator.obfuscateString(input)).toEqual(input)
+  })
+
+  test('obfuscateString applies obfuscation rules to input', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
+
+    const input = 'pii'
+    const obfuscator = new obfuscateModule.Obfuscator()
+    obfuscator.sharedContext = { agentIdentifier }
+
+    expect(obfuscator.obfuscateString(input)).toEqual(rules[0].replacement)
+  })
+
+  test('obfuscateString replaces input with * when replacement is not set', () => {
+    const newRules = [{
+      regex: rules[0].regex
+    }]
+
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(newRules)
+
+    const input = 'pii'
+    const obfuscator = new obfuscateModule.Obfuscator()
+    obfuscator.sharedContext = { agentIdentifier }
+
+    expect(obfuscator.obfuscateString(input)).toEqual('*')
+  })
+
+  test.each([
+    null,
+    undefined,
+    '',
+    123
+  ])('obfuscateString returns the input it is %s', (input) => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
+
+    const obfuscator = new obfuscateModule.Obfuscator()
+    obfuscator.sharedContext = { agentIdentifier }
+
+    expect(obfuscator.obfuscateString(input)).toEqual(input)
+  })
+})
+
+describe('getRules', () => {
+  test('should return configured rules', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
+
+    expect(obfuscateModule.getRules()).toEqual(rules)
+  })
+
+  test('should include the file protocol obfuscation', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
+    jest.spyOn(urlProtocolModule, 'isFileProtocol').mockReturnValue(rules)
+
+    expect(obfuscateModule.getRules()).toEqual(expect.arrayContaining([{
+      regex: /^file:\/\/(.*)/,
+      replacement: 'file://OBFUSCATED'
+    }]))
+  })
+
+  test.each([
+    null,
+    undefined
+  ])('should return an empty array when obfuscation rules are %s', (input) => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(input)
+
+    expect(obfuscateModule.getRules()).toEqual([])
+  })
+})
+
+describe('validateRules', () => {
+  test('should return true for empty array', () => {
+    expect(obfuscateModule.validateRules([])).toEqual(true)
+  })
+
+  test('should return true for valid rules', () => {
+    expect(obfuscateModule.validateRules(rules)).toEqual(true)
+  })
+
+  test.each([
+    null,
+    123,
+    {},
+    []
+  ])('should warn about an invalid regex type %s', (input) => {
+    const newRules = [{
+      regex: input,
+      replacement: rules[0].replacement
+    }]
+
+    expect(obfuscateModule.validateRules(newRules)).toEqual(false)
+    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining(
+      'contains a "regex" value with an invalid type'
+    ))
+  })
+
+  test('should warn about a missing regex with value', () => {
+    const newRules = [{
+      replacement: rules[0].replacement
+    }]
+
+    expect(obfuscateModule.validateRules(newRules)).toEqual(false)
+    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining(
+      'missing a "regex" value'
+    ))
+  })
+
+  test.each([
+    123,
+    {},
+    []
+  ])('should warn about an invalid replacement type %s', (input) => {
+    const newRules = [{
+      regex: rules[0].regex,
+      replacement: input
+    }]
+
+    expect(obfuscateModule.validateRules(newRules)).toEqual(false)
+    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining(
+      'contains a "replacement" value with an invalid type'
+    ))
+  })
+})

package/src/common/util/obfuscate.js

@@ -5,7 +5,7 @@ import { warn } from './console'
 
 var fileProtocolRule = {
   regex: /^file:\/\/(.*)/,
-  replacement: 'file://OBFUSCATED'
+  replacement: atob('ZmlsZTovL09CRlVTQ0FURUQ=')
 }
 export class Obfuscator extends SharedContext {
   shouldObfuscate () {
@@ -51,7 +51,7 @@ export function validateRules (rules) {
     if (!('regex' in rules[i])) {
       warn('An obfuscation replacement rule was detected missing a "regex" value.')
       invalidRegexDetected = true
-    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex.constructor === RegExp)) {
+    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex instanceof RegExp)) {
       warn('An obfuscation replacement rule contains a "regex" value with an invalid type (must be a string or RegExp)')
       invalidRegexDetected = true
     }

package/src/common/util/submit-data.js

@@ -97,10 +97,10 @@ submitData.img = function img ({ url }) {
  * @returns {boolean}
  */
 submitData.beacon = function ({ url, body }) {
-  // Navigator has to be bound to ensure it does not error in some browsers
-  // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
-  const send = window.navigator.sendBeacon.bind(window.navigator)
   try {
+    // Navigator has to be bound to ensure it does not error in some browsers
+    // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
+    const send = window.navigator.sendBeacon.bind(window.navigator)
     return send(url, body)
   } catch (err) {
     // if sendBeacon still trys to throw an illegal invocation error,