@newrelic/browser-agent 0.1.229 → 0.1.231

package/dist/cjs/common/timing/nav-timing.test.js

@@ -0,0 +1,192 @@
+"use strict";
+
+var _navTiming = require("./nav-timing");
+const offset = 123;
+const testValues = {
+  unloadEventStart: 1,
+  redirectStart: 2,
+  unloadEventEnd: 3,
+  redirectEnd: 4,
+  fetchStart: 5,
+  domainLookupStart: 6,
+  domainLookupEnd: 7,
+  connectStart: 8,
+  secureConnectionStart: 9,
+  connectEnd: 10,
+  requestStart: 11,
+  responseStart: 12,
+  responseEnd: 13,
+  domLoading: 14,
+  domInteractive: 15,
+  domContentLoadedEventStart: 16,
+  domContentLoadedEventEnd: 17,
+  domComplete: 18,
+  loadEventStart: 19,
+  loadEventEnd: 20,
+  type: 'reload',
+  redirectCount: 22
+};
+const legacyTestValues = {
+  unloadEventStart: offset + 1,
+  redirectStart: offset + 2,
+  unloadEventEnd: offset + 3,
+  redirectEnd: offset + 4,
+  fetchStart: offset + 5,
+  domainLookupStart: offset + 6,
+  domainLookupEnd: offset + 7,
+  connectStart: offset + 8,
+  secureConnectionStart: offset + 9,
+  connectEnd: offset + 10,
+  requestStart: offset + 11,
+  responseStart: offset + 12,
+  responseEnd: offset + 13,
+  domLoading: offset + 14,
+  domInteractive: offset + 15,
+  domContentLoadedEventStart: offset + 16,
+  domContentLoadedEventEnd: offset + 17,
+  domComplete: offset + 18,
+  loadEventStart: offset + 19,
+  loadEventEnd: offset + 20,
+  type: 'reload',
+  redirectCount: offset + 22
+};
+const expectedPT = {
+  of: offset,
+  n: 0,
+  u: 1,
+  r: 2,
+  ue: 3,
+  re: 4,
+  f: 5,
+  dn: 6,
+  dne: 7,
+  c: 8,
+  s: 9,
+  ce: 10,
+  rq: 11,
+  rp: 12,
+  rpe: 13,
+  dl: 14,
+  di: 15,
+  ds: 16,
+  de: 17,
+  dc: 18,
+  l: 19,
+  le: 20
+};
+const expectedPN = {
+  ty: 1,
+  rc: 22
+};
+describe('addPT()', () => {
+  test('an output object is populated with valid values', () => {
+    const output = (0, _navTiming.addPT)(offset, testValues, {});
+    expect(output).toEqual(expectedPT);
+  });
+  test('an object with invalid values is handled', () => {
+    const output = (0, _navTiming.addPT)(offset, {
+      ...testValues,
+      invalidValue: 'test'
+    }, {});
+    expect(output).toEqual(expectedPT);
+    const output2 = (0, _navTiming.addPT)(offset, {
+      ...testValues,
+      loadEventEnd: -1
+    }, {});
+    let expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output2).toEqual(expected);
+    const output3 = (0, _navTiming.addPT)(offset, {
+      ...testValues,
+      loadEventEnd: 'test'
+    }, {});
+    expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output3).toEqual(expected);
+    const output4 = (0, _navTiming.addPT)(offset, {
+      ...testValues,
+      loadEventEnd: null
+    }, {});
+    expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output4).toEqual(expected);
+    const legacyoutput = (0, _navTiming.addPT)(offset, {
+      ...legacyTestValues,
+      invalidValue: 'test'
+    }, {}, true);
+    expect(legacyoutput).toEqual(expectedPT);
+    const legacyoutput2 = (0, _navTiming.addPT)(offset, {
+      ...legacyTestValues,
+      loadEventEnd: -1
+    }, {}, true);
+    let legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput2).toEqual(expected);
+    const legacyoutput3 = (0, _navTiming.addPT)(offset, {
+      ...legacyTestValues,
+      loadEventEnd: 'test'
+    }, {}, true);
+    legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput3).toEqual(legacyexpected);
+    const legacyoutput4 = (0, _navTiming.addPT)(offset, {
+      ...legacyTestValues,
+      loadEventEnd: null
+    }, {}, true);
+    legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput4).toEqual(legacyexpected);
+  });
+  test('rounds values to integers', () => {
+    const output = (0, _navTiming.addPT)(offset, {
+      unloadEventStart: 3.14159
+    }, {});
+    expect(output.u).toEqual(3);
+    const legacyoutput = (0, _navTiming.addPT)(0, {
+      unloadEventStart: 3.14159
+    }, {}, true);
+    expect(legacyoutput.u).toEqual(3);
+  });
+  test('adds entries to navTimingValues', () => {
+    const beforeLength = _navTiming.navTimingValues.length;
+    (0, _navTiming.addPT)(offset, {
+      testValues
+    }, {});
+    const afterLength = _navTiming.navTimingValues.length;
+    expect(afterLength - beforeLength).toEqual(21); // 20 + value of n
+
+    const legacybeforeLength = _navTiming.navTimingValues.length;
+    (0, _navTiming.addPT)(offset, {
+      legacyTestValues
+    }, {}, true);
+    const legacyafterLength = _navTiming.navTimingValues.length;
+    expect(legacyafterLength - legacybeforeLength).toEqual(21); // 20 + value of n
+  });
+});
+
+describe('addPN()', () => {
+  test('an output object is populated with valid values', () => {
+    const output = (0, _navTiming.addPN)(testValues, {});
+    expect(output).toEqual(expectedPN);
+  });
+  test('adds entries to navTimingValues', () => {
+    const beforeLength = _navTiming.navTimingValues.length;
+    (0, _navTiming.addPN)(offset, {
+      testValues
+    }, {});
+    const afterLength = _navTiming.navTimingValues.length;
+    expect(afterLength - beforeLength).toEqual(2);
+  });
+});

package/dist/cjs/common/url/clean-url.test.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _cleanUrl = require("./clean-url");
+test.each([['http://domain.com/path?query=5', 'http://domain.com/path'], ['http://domain.com/path#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path']])('cleanURL should remove hash', (input, expected) => {
+  expect((0, _cleanUrl.cleanURL)(input)).toEqual(expected);
+});
+test.each([['http://domain.com/path?query=5', 'http://domain.com/path'], ['http://domain.com/path#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path#fragment#dumb'], ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path#fragment#dumb'], ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path#fragment/silly/dumber#dumbest']])('cleanURL should retain hash if second argument is true', (input, expected) => {
+  expect((0, _cleanUrl.cleanURL)(input, true)).toEqual(expected);
+});

package/dist/cjs/common/url/encode.test.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var encode = _interopRequireWildcard(require("./encode"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+describe('query string encoding', () => {
+  test('escapes string components except safe characters', () => {
+    const input = 'Asdf:, :, /@$;';
+    const expected = 'Asdf:,%20:,%20/@$;';
+    expect(encode.qs(input)).toEqual(expected);
+  });
+  test('null and undefined value returns \'null\'', () => {
+    expect(encode.qs(null)).toEqual('null');
+    expect(encode.qs(undefined)).toEqual('null');
+  });
+});
+describe('fromArray encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = ['a', 'b', 'c'];
+    const expected = 'ab';
+    expect(encode.fromArray(input, 2)).toEqual(expected);
+  });
+  test('fall back to largest whole chunk', () => {
+    const input = ['aa', 'bb', 'cc'];
+    const expected = 'aabb';
+    expect(encode.fromArray(input, 5)).toEqual(expected);
+  });
+});
+describe('object encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = {
+      foo: [1, 2, 3]
+    };
+    const expected = '&foo=%5B1,2%5D';
+    expect(encode.obj(input, 12)).toEqual(expected);
+  });
+  test('fall back to largest whole chunk', () => {
+    const input = {
+      bar: ['a', 'b', 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%22b%22%5D';
+    expect(encode.obj(input, 30)).toEqual(expected);
+  });
+  test('handles circular objects', () => {
+    const circular = {};
+    circular.circular = circular;
+    const input = {
+      bar: ['a', circular, 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%7B%7D,%22c%22%5D';
+    expect(encode.obj(input, 1000)).toEqual(expected);
+  });
+  test('handles circular arrays', () => {
+    const circular = [];
+    circular.push(circular);
+    const input = {
+      bar: ['a', circular, 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%5Bnull%5D,%22c%22%5D';
+    expect(encode.obj(input, 1000)).toEqual(expected);
+  });
+});
+describe('encode key value pairs as query params', () => {
+  test('ignores input when value is null or undefined', () => {
+    expect(encode.param('foo', null)).toEqual('');
+    expect(encode.param('foo', undefined)).toEqual('');
+  });
+  test('encodes key value pair correctly', () => {
+    expect(encode.param('foo', 'bar')).toEqual('&foo=bar');
+  });
+  test('ignores input when value is not a string', () => {
+    expect(encode.param('foo', {})).toEqual('');
+  });
+});

package/dist/cjs/common/url/location.js

@@ -9,6 +9,10 @@ exports.getLocation = getLocation;
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * This method only exists to support testing in JIL and can be removed once tests are migrated to WDIO.
+ * @returns global scope location
+ */
 function getLocation() {
   return '' + location;
 }

package/dist/cjs/common/url/location.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _location = require("./location");
+test('should always return a string', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({});
+  expect(typeof (0, _location.getLocation)()).toEqual('string');
+});
+test('should return window location', () => {
+  const expected = _faker.faker.internet.url();
+  jest.spyOn(window, 'location', 'get').mockReturnValue(expected);
+  expect((0, _location.getLocation)()).toEqual(expected);
+});

package/dist/cjs/common/url/parse-url.test.js

@@ -0,0 +1,111 @@
+"use strict";
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+afterEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+const urlTests = [{
+  input: 'http://example.com/path/name?qs=5&a=b',
+  expected: {
+    hostname: 'example.com',
+    pathname: '/path/name',
+    protocol: 'http',
+    port: '80',
+    sameOrigin: false
+  }
+}, {
+  input: 'http://foo:bar@example.com:8080/path/@name?qs=5&a=b',
+  expected: {
+    hostname: 'example.com',
+    pathname: '/path/@name',
+    protocol: 'http',
+    port: '8080',
+    sameOrigin: false
+  }
+}, {
+  input: 'https://foo:bar@example.com/path/name?qs=5&a=b',
+  expected: {
+    hostname: 'example.com',
+    pathname: '/path/name',
+    protocol: 'https',
+    port: '443',
+    sameOrigin: false
+  }
+}, {
+  input: '/path/name?qs=5&a=b',
+  expected: {
+    hostname: location.hostname,
+    pathname: '/path/name',
+    protocol: location.protocol.split(':')[0],
+    port: '80',
+    sameOrigin: true
+  }
+}, {
+  input: location.protocol + '//' + location.hostname + ':' + location.port + '/path/name?qs=5&a=b',
+  expected: {
+    hostname: location.hostname,
+    pathname: '/path/name',
+    protocol: location.protocol.split(':')[0],
+    port: '80',
+    sameOrigin: true
+  }
+}, {
+  input: 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==',
+  expected: {
+    protocol: 'data'
+  }
+}];
+test.each(urlTests)('verify url parsing inside browser scope', async _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: true,
+    globalScope: global
+  }));
+  const {
+    parseUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./parse-url')));
+  expect(parseUrl(input)).toEqual(expected);
+});
+test.each(urlTests)('verify url parsing outside browser scope', async _ref2 => {
+  let {
+    input,
+    expected
+  } = _ref2;
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: false,
+    globalScope: global
+  }));
+  const {
+    parseUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./parse-url')));
+  expect(parseUrl(input)).toEqual(expected);
+});
+test('should cache parsed urls', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: true,
+    globalScope: global
+  }));
+  const input = 'http://example.com/';
+  const expected = {
+    hostname: 'example.com',
+    pathname: '/',
+    protocol: 'http',
+    port: '80',
+    sameOrigin: false
+  };
+  jest.spyOn(document, 'createElement');
+  const {
+    parseUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./parse-url')));
+  parseUrl(input);
+  expect(parseUrl(input)).toEqual(expected);
+  expect(document.createElement).toHaveBeenCalledTimes(1);
+});

package/dist/cjs/common/url/protocol.js

@@ -3,23 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.protocol = void 0;
+exports.isFileProtocol = isFileProtocol;
 var _globalScope = require("../util/global-scope");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const protocol = {
-  isFileProtocol: isFileProtocol,
-  supportabilityMetricSent: false
-};
-exports.protocol = protocol;
 function isFileProtocol() {
-  let isFile = Boolean((0, _globalScope.getGlobalScope)()?.location?.protocol === 'file:');
-  if (isFile) {
-    //metrics.recordSupportability('Generic/FileProtocol/Detected') -- may be implemented later? Probably make sure it's once per window
-    protocol.supportabilityMetricSent = true;
-  }
-  return isFile;
+  return Boolean(_globalScope.globalScope?.location?.protocol === 'file:');
 }

package/dist/cjs/common/url/protocol.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _protocol = require("./protocol");
+test('should return true when location url contains file protocol', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({
+    protocol: 'file:'
+  });
+  expect((0, _protocol.isFileProtocol)()).toEqual(true);
+});
+test('should return false when location url does not contains file protocol', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({
+    protocol: 'http:'
+  });
+  expect((0, _protocol.isFileProtocol)()).toEqual(false);
+});

package/dist/cjs/common/util/console.js

@@ -11,7 +11,7 @@ exports.warn = warn;
  * @returns
  */
 function warn(message, secondary) {
-  if (!console || !console.warn || typeof console.warn !== 'function') return;
-  console.warn(`New Relic: ${message}`);
+  if (typeof console.warn !== 'function') return;
+  console.warn("New Relic: ".concat(message));
   if (secondary) console.warn(secondary);
 }

package/dist/cjs/common/util/map-own.js

@@ -3,22 +3,29 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.mapOwn = mapOwn;
+exports.mapOwn = void 0;
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var has = Object.prototype.hasOwnProperty;
-function mapOwn(obj, fn) {
-  var results = [];
-  var key = '';
-  var i = 0;
-  for (key in obj) {
-    if (has.call(obj, key)) {
-      results[i] = fn(key, obj[key]);
-      i += 1;
-    }
-  }
-  return results;
-}
+/**
+ * @typedef {function} MapOwnCallback
+ * @param {string} key Object key
+ * @param {any} value Object value
+ * @returns {any}
+ */
+
+/**
+ * Iterates the own enumerable properties of an object passing the key and value pair to a given
+ * callback function.
+ * @param {object} obj Input object to iterate over. If null or undefined, an empty array will be returned.
+ * @param {MapOwnCallback} fn A callback function called for each property. The callback should take the key
+ * and value from the object iteration and return some value.
+ * @returns {any[]} An array of values returned by the callback function.
+ */
+const mapOwn = (obj, fn) => Object.entries(obj || {}).map(_ref => {
+  let [key, value] = _ref;
+  return fn(key, value);
+});
+exports.mapOwn = mapOwn;

package/dist/cjs/common/util/map-own.test.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _mapOwn = require("./map-own");
+test('enumerates the object properties', () => {
+  const callback = jest.fn();
+  const input = {
+    foo: 'bar'
+  };
+  (0, _mapOwn.mapOwn)(input, callback);
+  expect(callback).toHaveBeenCalledWith('foo', 'bar');
+});
+test('return array of results from callback invocation', () => {
+  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
+  const input = {
+    foo: 'bar',
+    biz: 'baz'
+  };
+  const result = (0, _mapOwn.mapOwn)(input, callback);
+  expect(result.length).toEqual(2);
+  expect(result).toContain('foo:bar');
+  expect(result).toContain('biz:baz');
+});
+test('does not iterate symbol properties', () => {
+  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
+  const input = {
+    foo: 'bar',
+    [Symbol.for('biz')]: 'baz'
+  };
+  const result = (0, _mapOwn.mapOwn)(input, callback);
+  expect(result.length).toEqual(1);
+});
+test('does not iterate inherited properties', () => {
+  function F() {}
+  F.prototype = {
+    biz: 'baz'
+  };
+  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
+  const input = new F();
+  input.foo = 'bar';
+  const result = (0, _mapOwn.mapOwn)(input, callback);
+  expect(result.length).toEqual(1);
+});
+test.each([null, undefined])('returns empty array when passed object is null or undefined', input => {
+  const callback = jest.fn();
+  const result = (0, _mapOwn.mapOwn)(input, callback);
+  expect(Array.isArray(result)).toEqual(true);
+  expect(result.length).toEqual(0);
+  expect(callback).toHaveBeenCalledTimes(0);
+});

package/dist/cjs/common/util/obfuscate.js

@@ -46,7 +46,7 @@ function getRules(agentIdentifier) {
   var rules = [];
   var configRules = (0, _config.getConfigurationValue)(agentIdentifier, 'obfuscate') || [];
   rules = rules.concat(configRules);
-  if (_protocol.protocol.isFileProtocol()) rules.push(fileProtocolRule);
+  if ((0, _protocol.isFileProtocol)()) rules.push(fileProtocolRule);
   // could add additional runtime/environment-specific rules here
 
   return rules;

package/dist/cjs/common/util/submit-data.js

@@ -53,7 +53,8 @@ submitData.xhrGet = function xhrGet(url) {
  * @param {boolean} sync
  * @returns {XMLHttpRequest}
  */
-submitData.xhr = function xhr(url, body, sync, method = 'POST') {
+submitData.xhr = function xhr(url, body, sync) {
+  let method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'POST';
   var request = new XMLHttpRequest();
   request.open(method, url, !sync);
   try {
@@ -94,6 +95,13 @@ submitData.img = function img(url) {
 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(navigator);
-  return send(url, body);
+  const send = window.navigator.sendBeacon.bind(window.navigator);
+  try {
+    return send(url, body);
+  } catch (err) {
+    // if sendBeacon still trys to throw an illegal invocation error,
+    // we can catch here and return.  The harvest module will fallback to use
+    // .img to try to send
+    return false;
+  }
 };

package/dist/cjs/common/window/page-visibility.js

@@ -15,13 +15,15 @@ var _eventListenerOpts = require("../event-listener/event-listener-opts");
  * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
  * @returns void
  */
-function subscribeToVisibilityChange(cb, toHiddenOnly = false) {
+function subscribeToVisibilityChange(cb) {
+  let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   (0, _eventListenerOpts.documentAddEventListener)('visibilitychange', handleVisibilityChange);
   return;
   function handleVisibilityChange() {
     if (toHiddenOnly) {
       // trigger cb on change to hidden state only
-      if (document.visibilityState == 'hidden') cb();else return;
+      if (document.visibilityState == 'hidden') cb();
+      return;
     }
     cb(document.visibilityState);
   }