@newrelic/browser-agent 0.1.229 → 0.1.231

package/dist/cjs/common/event-emitter/register-handler.test.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+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; }
+jest.mock('./handle', () => ({
+  __esModule: true,
+  handleEE: {}
+}));
+afterEach(() => {
+  jest.resetModules();
+  jest.resetAllMocks();
+});
+test('should default group to "feature"', async () => {
+  const {
+    handleEE
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./handle')));
+  const {
+    registerHandler
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./register-handler')));
+  const eventType = _faker.faker.datatype.uuid();
+  const eventHandler = jest.fn();
+  registerHandler(eventType, eventHandler);
+  expect(registerHandler.handlers['feature']).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([handleEE, eventHandler])]
+  }));
+});
+test('should use the provided group', async () => {
+  const {
+    handleEE
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./handle')));
+  const {
+    registerHandler
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./register-handler')));
+  const eventType = _faker.faker.datatype.uuid();
+  const eventGroup = _faker.faker.datatype.uuid();
+  const eventHandler = jest.fn();
+  registerHandler(eventType, eventHandler, eventGroup);
+  expect(registerHandler.handlers[eventGroup]).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([handleEE, eventHandler])]
+  }));
+});
+test('should use the provided event-emitter', async () => {
+  const {
+    registerHandler
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./register-handler')));
+  const scopedEE = {};
+  const eventType = _faker.faker.datatype.uuid();
+  const eventGroup = _faker.faker.datatype.uuid();
+  const eventHandler = jest.fn();
+  registerHandler(eventType, eventHandler, eventGroup, scopedEE);
+  expect(registerHandler.handlers[eventGroup]).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([scopedEE, eventHandler])]
+  }));
+});

package/dist/cjs/common/event-listener/event-listener-opts.js

@@ -37,10 +37,12 @@ function eventListenerOpts(useCapture, abortSignal) {
 }
 
 /** Do not use this within the worker context. */
-function windowAddEventListener(event, listener, capture = false) {
+function windowAddEventListener(event, listener) {
+  let capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   window.addEventListener(event, listener, eventListenerOpts(capture));
 }
 /** Do not use this within the worker context. */
-function documentAddEventListener(event, listener, capture = false) {
+function documentAddEventListener(event, listener) {
+  let capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   document.addEventListener(event, listener, eventListenerOpts(capture));
 }

package/dist/cjs/common/harvest/harvest-scheduler.js

@@ -43,7 +43,8 @@ class HarvestScheduler extends _sharedContext.SharedContext {
     this.started = true;
     this.scheduleHarvest(initialDelay != null ? initialDelay : this.interval);
   }
-  stopTimer(permanently = false) {
+  stopTimer() {
+    let permanently = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     this.aborted = permanently; // stopping permanently is same as aborting, but this function also cleans up the setTimeout loop
     this.started = false;
     if (this.timeoutHandle) {

package/dist/cjs/common/harvest/harvest.js

@@ -17,7 +17,7 @@ var _eventListenerOpts = require("../event-listener/event-listener-opts");
 var _obfuscate = require("../util/obfuscate");
 var _traverse = require("../util/traverse");
 var _sharedContext = require("../context/shared-context");
-var _environmentVariables = require("../constants/environment-variables");
+var _env = require("../constants/env.npm");
 var _globalScope = require("../util/global-scope");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
@@ -71,6 +71,7 @@ class Harvest extends _sharedContext.SharedContext {
   * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
   */
   send(endpoint, singlePayload, opts, submitMethod, cbFinished) {
+    var _this = this;
     var makeBody = createAccumulator();
     var makeQueryString = createAccumulator();
     if (singlePayload.body) (0, _mapOwn.mapOwn)(singlePayload.body, makeBody);
@@ -79,11 +80,18 @@ class Harvest extends _sharedContext.SharedContext {
       body: makeBody(),
       qs: makeQueryString()
     };
-    var caller = this.obfuscator.shouldObfuscate() ? (...args) => this.obfuscateAndSend(...args) : (...args) => this._send(...args);
+    var caller = this.obfuscator.shouldObfuscate() ? function () {
+      return _this.obfuscateAndSend(...arguments);
+    } : function () {
+      return _this._send(...arguments);
+    };
     return caller(endpoint, payload, opts, submitMethod, cbFinished);
   }
   obfuscateAndSend(endpoint, payload, opts, submitMethod, cbFinished) {
-    (0, _traverse.applyFnToProps)(payload, (...args) => this.obfuscator.obfuscateString(...args), 'string', ['e']);
+    var _this2 = this;
+    (0, _traverse.applyFnToProps)(payload, function () {
+      return _this2.obfuscator.obfuscateString(...arguments);
+    }, 'string', ['e']);
     return this._send(endpoint, payload, opts, submitMethod, cbFinished);
   }
   _send(endpoint, payload, opts, submitMethod, cbFinished) {
@@ -117,6 +125,9 @@ class Harvest extends _sharedContext.SharedContext {
       fullUrl = url + (0, _encode.obj)(payload.body, agentRuntime.maxBytes);
     }
 
+    // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
+    agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0;
+
     /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
         we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon. */
@@ -154,7 +165,7 @@ class Harvest extends _sharedContext.SharedContext {
     var info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
     var location = (0, _cleanUrl.cleanURL)((0, _location.getLocation)());
     var ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
-    return ['?a=' + info.applicationID, (0, _encode.param)('sa', info.sa ? '' + info.sa : ''), (0, _encode.param)('v', _environmentVariables.VERSION), transactionNameParam(info), (0, _encode.param)('ct', runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
+    return ['?a=' + info.applicationID, (0, _encode.param)('sa', info.sa ? '' + info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(info), (0, _encode.param)('ct', runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
     // ck param DEPRECATED - still expected by backend
     '&s=' + (runtime.sessionId || '0'),
     // the 0 id encaps all untrackable and default traffic

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