@newrelic/browser-agent 0.1.230 → 0.1.231

package/dist/cjs/common/ids/id.js

@@ -11,15 +11,23 @@ var _globalScope = require("../util/global-scope");
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// Start assigning ids at 1 so 0 can always be used for WindowOrWorkerGlobalScope, without
+// Start assigning ids at 1 so 0 can always be used for Window or WorkerGlobalScope, without
 // actually setting it (which would create a global variable).
+let index = 1;
+const prop = 'nr@id';
 
-var index = 1;
-var prop = 'nr@id';
-
-// Always returns id of obj, may tag obj with an id in the process.
+/**
+ * Tags a specified object with an identifier if it does not already
+ * have one. If the object is the global scope, zero will be returned
+ * and the object will not be modified. If the object already contains
+ * an identifier, it will be returned without modification. If the passed
+ * value is not an object, function, or array, -1 will be returned without
+ * modifying the passed value.
+ * @param {object|function|array} obj Object to be tagged with an identifier
+ * @returns {number} Identifier of the given object
+ */
 function id(obj) {
-  var type = typeof obj;
+  const type = typeof obj;
   // We can only tag objects, functions, and arrays with ids.
   // For all primitive values we instead return -1.
   if (!obj || !(type === 'object' || type === 'function')) return -1;

package/dist/cjs/common/ids/id.test.js

@@ -0,0 +1,85 @@
+"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; }
+let idFn;
+beforeEach(async () => {
+  idFn = (await Promise.resolve().then(() => _interopRequireWildcard(require('./id')))).id;
+});
+afterEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+test.each([{
+  input: undefined,
+  expected: -1,
+  title: 'id of undefined is -1'
+}, {
+  input: null,
+  expected: -1,
+  title: 'id of null is -1'
+}, {
+  input: 2,
+  expected: -1,
+  title: 'id of number is -1'
+}, {
+  input: 'foo',
+  expected: -1,
+  title: 'id of string is -1'
+}])('$title', _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
+  const result = idFn(input);
+  expect(typeof result).toEqual('number');
+  expect(result).toEqual(expected);
+});
+test('id values increment sequentially', () => {
+  const inputA = {};
+  const inputB = {};
+  const resultA = idFn(inputA);
+  const resultB = idFn(inputB);
+  expect(resultA - resultB).toEqual(-1);
+});
+test('id is correctly assigned to function type', () => {
+  const input = jest.fn();
+  const result = idFn(input);
+  expect(result).toEqual(1);
+  expect(input['nr@id']).toEqual(1);
+});
+test('id is correctly assigned to object type', () => {
+  const input = {};
+  const result = idFn(input);
+  expect(result).toEqual(1);
+  expect(input['nr@id']).toEqual(1);
+});
+test('id is the same when called twice on the same input', () => {
+  const input = {};
+  const result1 = idFn(input);
+  const result2 = idFn(input);
+  expect(result1).toEqual(1);
+  expect(result2).toEqual(1);
+  expect(input['nr@id']).toEqual(1);
+});
+test('id is zero on global scope', async () => {
+  const result = idFn(global);
+  expect(result).toEqual(0);
+});
+test('id on prototype is correctly inherited', () => {
+  const fn = jest.fn();
+  const a = {};
+  idFn(a);
+  fn.prototype = a;
+  const b = new fn();
+  expect(b['nr@id']).toEqual(a['nr@id']);
+});
+test('id on prototype is different from instance', () => {
+  const fn = jest.fn();
+  const a = {};
+  idFn(a);
+  fn.prototype = a;
+  const b = new fn();
+  const result = idFn(b);
+  expect(b['nr@id']).toEqual(result);
+});

package/dist/cjs/common/ids/unique-id.js

@@ -13,72 +13,96 @@ var _globalScope = require("../util/global-scope");
  * SPDX-License-Identifier: Apache-2.0
  */
 
+const uuidv4Template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+
+/**
+ * Creates a random single hexadecimal value from a provided random value
+ * table and corresponding index. If a random value table is not provided,
+ * Math.random will be used to generate the value.
+ *
+ * @param {Uint8Array} valueTable Random value table typically generated using
+ * the built-in crypto engine.
+ * @param {int} tableIndex The index of the value table to use for generating
+ * the hexadecimal value.
+ * @returns {int} single hexadecimal value in decimal format
+ */
+function getRandomValue(valueTable, tableIndex) {
+  if (valueTable) {
+    /**
+     * The value table could have any number value in the given index. Use
+     * bitwise AND to ensure the value we generate is a valid hex value.
+     * x & 15 will ensure the value converted to hex using `toString(16)`
+     * falls within the range of 0 and 15 inclusively.
+     */
+    return valueTable[tableIndex] & 15;
+  } else {
+    return Math.random() * 16 | 0;
+  }
+}
+
+/**
+ * Generates a RFC compliant UUIDv4 using native browser crypto engine. If the browser
+ * does not support the crypto engine, the function will fallback to insecure Math.random()
+ * @returns {string} uuid version 4 string
+ */
 function generateUuid() {
-  var randomVals = null;
-  var rvIndex = 0;
-  var crypto = _globalScope.globalScope?.crypto || _globalScope.globalScope?.msCrypto;
+  const crypto = _globalScope.globalScope?.crypto || _globalScope.globalScope?.msCrypto;
+  let randomValueTable;
+  let randomValueIndex = 0;
   if (crypto && crypto.getRandomValues) {
     // eslint-disable-next-line
-    randomVals = crypto.getRandomValues(new Uint8Array(31));
-  }
-  function getRandomValue() {
-    if (randomVals) {
-      // same as % 16
-      return randomVals[rvIndex++] & 15;
-    } else {
-      return Math.random() * 16 | 0;
-    }
+    randomValueTable = crypto.getRandomValues(new Uint8Array(31));
   }
-
-  // v4 UUID
-  var template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-  var id = '';
-  var c;
-  for (var i = 0; i < template.length; i++) {
-    c = template[i];
-    if (c === 'x') {
-      id += getRandomValue().toString(16);
-    } else if (c === 'y') {
+  return uuidv4Template.split('').map(templateInput => {
+    if (templateInput === 'x') {
+      return getRandomValue(randomValueTable, ++randomValueIndex).toString(16);
+    } else if (templateInput === 'y') {
       // this is the uuid variant per spec (8, 9, a, b)
       // % 4, then shift to get values 8-11
-      c = getRandomValue() & 0x3 | 0x8;
-      id += c.toString(16);
+      return (getRandomValue() & 0x3 | 0x8).toString(16);
     } else {
-      id += c;
+      return templateInput;
     }
+  }).join('');
+}
+
+/**
+ * Generates a string of the given length containing only hexadecimal
+ * value 0-9 and a-f.
+ * @param {int} length length of the string to generate
+ * @returns {string} generated hex string
+ */
+function generateRandomHexString(length) {
+  const crypto = _globalScope.globalScope?.crypto || _globalScope.globalScope?.msCrypto;
+  let randomValueTable;
+  let randomValueIndex = 0;
+  if (crypto && crypto.getRandomValues) {
+    // eslint-disable-next-line
+    randomValueTable = crypto.getRandomValues(new Uint8Array(31));
   }
-  return id;
+  const chars = [];
+  for (var i = 0; i < length; i++) {
+    chars.push(getRandomValue(randomValueTable, ++randomValueIndex).toString(16));
+  }
+  return chars.join('');
 }
 
-// 16-character hex string (per DT spec)
+/**
+ * Generates a 16 character length hexadecimal string.
+ * per DT-spec.
+ * @see generateRandomHexString
+ * @returns {string} generated hex string
+ */
 function generateSpanId() {
   return generateRandomHexString(16);
 }
 
-// 32-character hex string (per DT spec)
+/**
+ * Generates a 32 character length hexadecimal string.
+ * per DT-spec.
+ * @see generateRandomHexString
+ * @returns {string} generated hex string
+ */
 function generateTraceId() {
   return generateRandomHexString(32);
-}
-function generateRandomHexString(length) {
-  var randomVals = null;
-  var rvIndex = 0;
-  var crypto = self.crypto || self.msCrypto;
-  // eslint-disable-next-line
-  if (crypto && crypto.getRandomValues && Uint8Array) {
-    // eslint-disable-next-line
-    randomVals = crypto.getRandomValues(new Uint8Array(31));
-  }
-  var chars = [];
-  for (var i = 0; i < length; i++) {
-    chars.push(getRandomValue().toString(16));
-  }
-  return chars.join('');
-  function getRandomValue() {
-    if (randomVals) {
-      // same as % 16
-      return randomVals[rvIndex++] & 15;
-    } else {
-      return Math.random() * 16 | 0;
-    }
-  }
 }

package/dist/cjs/common/ids/unique-id.test.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _crypto = _interopRequireDefault(require("crypto"));
+var uniqueId = _interopRequireWildcard(require("./unique-id"));
+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; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const getRandomValues = jest.fn(arr => _crypto.default.randomBytes(arr.length));
+afterEach(() => {
+  delete global.crypto;
+});
+describe('generateUuid', () => {
+  const uuidv4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+  test('should generate a uuidv4 that matches the expected format', () => {
+    const id = uniqueId.generateUuid();
+    expect(uuidv4Regex.test(id)).toEqual(true);
+  });
+  test('should support using native crypto library', () => {
+    global.crypto = {
+      getRandomValues
+    };
+    const id = uniqueId.generateUuid();
+    expect(uuidv4Regex.test(id)).toEqual(true);
+    expect(getRandomValues).toHaveBeenCalledTimes(1);
+  });
+});
+describe('generateRandomHexString', () => {
+  const hexRegex = /^[0-9a-f]{8}$/;
+  test('should generate a valid hex string', () => {
+    const id = uniqueId.generateRandomHexString(8);
+    expect(hexRegex.test(id)).toEqual(true);
+  });
+  test('should support using native crypto library', () => {
+    global.crypto = {
+      getRandomValues
+    };
+    const id = uniqueId.generateRandomHexString(8);
+    expect(hexRegex.test(id)).toEqual(true);
+    expect(getRandomValues).toHaveBeenCalledTimes(1);
+  });
+});
+test('generateSpanId should generate a 16 character hex string', () => {
+  const id = uniqueId.generateSpanId();
+  expect(/^[0-9a-f]{16}$/.test(id)).toEqual(true);
+});
+test('generateTraceId should generate a 32 character hex string', () => {
+  const id = uniqueId.generateTraceId();
+  expect(/^[0-9a-f]{32}$/.test(id)).toEqual(true);
+});

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

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.addPN = addPN;
 exports.addPT = addPT;
-exports.addRel = addRel;
 exports.navTimingValues = void 0;
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
@@ -35,43 +34,65 @@ var LOAD_EVENT = 'loadEvent';
 var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent';
 var navTimingValues = [];
 exports.navTimingValues = navTimingValues;
-function addPT(offset, pt, v) {
+function getPntType(type) {
+  if (typeof type == 'number') return type;
+  const types = {
+    navigate: undefined,
+    reload: 1,
+    back_forward: 2,
+    prerender: 3
+  };
+  return types[type];
+}
+function addPT(offset, pt) {
+  let v = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let isL1Api = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (!pt) return;
   v.of = offset;
-  addRel(offset, offset, v, 'n');
-  addRel(pt[UNLOAD_EVENT + START], offset, v, 'u');
-  addRel(pt[REDIRECT + START], offset, v, 'r');
-  addRel(pt[UNLOAD_EVENT + END], offset, v, 'ue');
-  addRel(pt[REDIRECT + END], offset, v, 're');
-  addRel(pt['fetch' + START], offset, v, 'f');
-  addRel(pt[DOMAIN_LOOKUP + START], offset, v, 'dn');
-  addRel(pt[DOMAIN_LOOKUP + END], offset, v, 'dne');
-  addRel(pt['c' + ONNECT + START], offset, v, 'c');
-  addRel(pt['secureC' + ONNECT + 'ion' + START], offset, v, 's');
-  addRel(pt['c' + ONNECT + END], offset, v, 'ce');
-  addRel(pt[REQUEST + START], offset, v, 'rq');
-  addRel(pt[RESPONSE + START], offset, v, 'rp');
-  addRel(pt[RESPONSE + END], offset, v, 'rpe');
-  addRel(pt.domLoading, offset, v, 'dl');
-  addRel(pt.domInteractive, offset, v, 'di');
-  addRel(pt[DOM_CONTENT_LOAD_EVENT + START], offset, v, 'ds');
-  addRel(pt[DOM_CONTENT_LOAD_EVENT + END], offset, v, 'de');
-  addRel(pt.domComplete, offset, v, 'dc');
-  addRel(pt[LOAD_EVENT + START], offset, v, 'l');
-  addRel(pt[LOAD_EVENT + END], offset, v, 'le');
+  handleValue(v.of, v, 'n', true);
+  handleValue(pt[UNLOAD_EVENT + START], v, 'u', isL1Api);
+  handleValue(pt[REDIRECT + START], v, 'r', isL1Api);
+  handleValue(pt[UNLOAD_EVENT + END], v, 'ue', isL1Api);
+  handleValue(pt[REDIRECT + END], v, 're', isL1Api);
+  handleValue(pt['fetch' + START], v, 'f', isL1Api);
+  handleValue(pt[DOMAIN_LOOKUP + START], v, 'dn', isL1Api);
+  handleValue(pt[DOMAIN_LOOKUP + END], v, 'dne', isL1Api);
+  handleValue(pt['c' + ONNECT + START], v, 'c', isL1Api);
+  handleValue(pt['secureC' + ONNECT + 'ion' + START], v, 's', isL1Api);
+  handleValue(pt['c' + ONNECT + END], v, 'ce', isL1Api);
+  handleValue(pt[REQUEST + START], v, 'rq', isL1Api);
+  handleValue(pt[RESPONSE + START], v, 'rp', isL1Api);
+  handleValue(pt[RESPONSE + END], v, 'rpe', isL1Api);
+  handleValue(pt.domLoading, v, 'dl', isL1Api);
+  handleValue(pt.domInteractive, v, 'di', isL1Api);
+  handleValue(pt[DOM_CONTENT_LOAD_EVENT + START], v, 'ds', isL1Api);
+  handleValue(pt[DOM_CONTENT_LOAD_EVENT + END], v, 'de', isL1Api);
+  handleValue(pt.domComplete, v, 'dc', isL1Api);
+  handleValue(pt[LOAD_EVENT + START], v, 'l', isL1Api);
+  handleValue(pt[LOAD_EVENT + END], v, 'le', isL1Api);
   return v;
 }
 
 // Add Performance Navigation values to the given object
 function addPN(pn, v) {
-  addRel(pn.type, 0, v, 'ty');
-  addRel(pn.redirectCount, 0, v, 'rc');
+  handleValue(getPntType(pn.type), v, 'ty');
+  handleValue(pn.redirectCount, v, 'rc');
   return v;
 }
-function addRel(value, offset, obj, prop) {
-  var relativeValue;
+function handleValue(value, obj, prop, isOldApi) {
+  /*
+  For L2 Timing API, the value will already be a relative-to-previous-document DOMHighResTimeStamp.
+  For L1 (deprecated) Timing, the value is an UNIX epoch timestamp, which we will convert to a relative time using our offset.
+  PNT.type is reported as undefined, 1, 2, etc -- note that zero-value properties will be recorded as 'undefined', however DEM interprets undefined "types" as "navigate"
+  */
   if (typeof value === 'number' && value > 0) {
-    relativeValue = Math.max(Math.round(value - offset), 0);
-    obj[prop] = relativeValue;
+    // note that zero-value properties will be recorded as 'undefined'
+    if (isOldApi) {
+      const offset = obj?.of > 0 ? obj.of : 0; // expect an epoch timestamp, if called by addPT
+      value = Math.max(value - offset, 0);
+    }
+    value = Math.round(value);
+    obj[prop] = value;
   }
-  navTimingValues.push(relativeValue);
+  navTimingValues.push(value);
 }

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);
+});