@newrelic/browser-agent 0.1.230 → 1.232.0

package/dist/cjs/common/storage/first-party-cookies.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FirstPartyCookies = void 0;
+class FirstPartyCookies {
+  constructor(domain) {
+    this.domain = domain;
+  }
+  get(name) {
+    try {
+      var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+      if (match) return match[2];
+    } catch (err) {
+      return '';
+    }
+  }
+  set(key, value) {
+    try {
+      const cookie = "".concat(key, "=").concat(value, "; Domain=").concat(domain, "; Path=/");
+      document.cookie = cookie;
+    } catch (err) {
+      return;
+    }
+  }
+  remove(key) {
+    try {
+      return document.cookie = "".concat(key, "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=").concat(domain, "; Path=/");
+    } catch (err) {
+      return;
+    }
+  }
+}
+exports.FirstPartyCookies = FirstPartyCookies;

package/dist/cjs/common/storage/local-memory.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalMemory = void 0;
+class LocalMemory {
+  constructor() {
+    let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this.state = initialState;
+  }
+  get(key) {
+    try {
+      return this.state[key];
+    } catch (err) {
+      return '';
+    }
+  }
+  set(key, value) {
+    try {
+      if (value === undefined || value === null) return this.remove(key);
+      this.state[key] = value;
+    } catch (err) {
+      return;
+    }
+  }
+  remove(key) {
+    try {
+      delete this.state[key];
+    } catch (err) {
+      return;
+    }
+  }
+}
+exports.LocalMemory = LocalMemory;

package/dist/cjs/common/storage/local-memory.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _localMemory = require("./local-memory");
+test('Local-memory', () => {
+  const LM = new _localMemory.LocalMemory({
+    test: 1
+  });
+  expect(LM.state).toEqual({
+    test: 1
+  });
+  expect(LM.get('test')).toEqual(1);
+  LM.set('test', 2);
+  expect(LM.get('test')).toEqual(2);
+  LM.set('test');
+  expect(LM.get('test')).toEqual(undefined);
+  LM.set('test', 2);
+  expect(LM.get('test')).toEqual(2);
+  LM.remove('test');
+  expect(LM.get('test')).toEqual(undefined);
+});

package/dist/cjs/common/storage/local-storage.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalStorage = void 0;
+class LocalStorage {
+  get(key) {
+    try {
+      // localStorage strangely type-casts non-existing data to "null"...
+      // Cast it back to undefined if it doesnt exist
+      return localStorage.getItem(key) || undefined;
+    } catch (err) {
+      return '';
+    }
+  }
+  set(key, value) {
+    try {
+      if (value === undefined || value === null) return this.remove(key);
+      return localStorage.setItem(key, value);
+    } catch (err) {
+      return;
+    }
+  }
+  remove(key) {
+    try {
+      localStorage.removeItem(key);
+    } catch (err) {
+      return;
+    }
+  }
+}
+exports.LocalStorage = LocalStorage;

package/dist/cjs/common/storage/local-storage.test.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _localStorage = require("./local-storage");
+test('Local-memory', () => {
+  const LS = new _localStorage.LocalStorage();
+  LS.set('test', 1);
+  expect(LS.get('test')).toEqual('1');
+  LS.set('test');
+  expect(LS.get('test')).toEqual(undefined);
+  LS.set('test', 2);
+  expect(LS.get('test')).toEqual('2');
+  LS.remove('test');
+  expect(LS.get('test')).toEqual(undefined);
+});

package/dist/cjs/common/timer/interaction-timer.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InteractionTimer = void 0;
+var _timer = require("./timer");
+var _pageVisibility = require("../window/page-visibility");
+var _invoke = require("../util/invoke");
+var _globalScope = require("../util/global-scope");
+class InteractionTimer extends _timer.Timer {
+  constructor(opts, ms) {
+    super(opts, ms);
+    this.onRefresh = opts.onRefresh;
+    this.onPause = opts.onPause;
+
+    // used by pause/resume
+    this.remainingMs = undefined;
+    if (!opts.refreshEvents) opts.refreshEvents = ['click', 'keydown', 'scroll'];
+
+    // the abort controller is used to "reset" the event listeners and prevent them from duplicating when new sessions are created
+    try {
+      this.abortController = new AbortController();
+    } catch (e) {
+      // this try-catch can be removed when IE11 is completely unsupported & gone
+    }
+    if (_globalScope.isBrowserScope && opts.ee) {
+      if (opts.ee) {
+        const debouncedRefresh = (0, _invoke.debounce)(this.refresh.bind(this), 500, {
+          leading: true
+        });
+        opts.ee.on('fn-end', evts => {
+          if (opts.refreshEvents.includes(evts?.[0]?.type)) {
+            debouncedRefresh();
+          }
+        });
+      }
+
+      // watch for the vis state changing.  If the page is hidden, the local inactivity timer should be paused
+      // if the page is brought BACK to visibility and the timer hasnt "naturally" expired, refresh the timer...
+      // this is to support the concept that other tabs could be experiencing activity.  The thought would be that
+      // "backgrounded" tabs would pause, while "closed" tabs that "reopen" will just instantiate a new SessionEntity class if restored
+      // which will do a "hard" check of the timestamps.
+
+      // NOTE -- this does not account for 2 browser windows open side by side, blurring/focusing between them
+      // IF DEEMED necessary, more event handling would be needed to account for this.
+      (0, _pageVisibility.subscribeToVisibilityChange)(state => {
+        if (state === 'hidden') this.pause();
+        // vis change --> visible is treated like a new interaction with the page
+        else this.refresh();
+      }, false, false, this.abortController?.signal);
+    }
+  }
+  abort() {
+    this.clear();
+    this.abortController?.abort();
+  }
+  pause() {
+    this.onPause?.();
+    clearTimeout(this.timer);
+    this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp);
+  }
+  refresh(cb, ms) {
+    this.clear();
+    this.timer = this.create(cb, ms);
+    this.startTimestamp = Date.now();
+    this.remainingMs = undefined;
+    this.onRefresh?.();
+  }
+
+  // NOT CURRENTLY UTILIZED BY ANYTHING
+  // resume () {
+  //   if (!this.remainingMs || !this.isValid()) return
+  //   this.timer = this.create(this.cb, this.remainingMs)
+  //   this.remainingMs = undefined
+  // }
+}
+exports.InteractionTimer = InteractionTimer;

package/dist/cjs/common/timer/interaction-timer.test.js

@@ -0,0 +1,216 @@
+"use strict";
+
+var _interactionTimer = require("./interaction-timer");
+jest.useFakeTimers();
+let now;
+beforeEach(() => {
+  now = Date.now();
+  jest.setSystemTime(now);
+});
+afterEach(() => {
+  jest.clearAllMocks();
+});
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
+  });
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    const requiredKeys = ['onEnd', 'refresh', 'initialMs', 'startTimestamp', 'timer'];
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
+  });
+  test('required keys are enforced', () => {
+    try {
+      new _interactionTimer.InteractionTimer({}, 100);
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'));
+    }
+    try {
+      new _interactionTimer.InteractionTimer({
+        onEnd: jest.fn()
+      });
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'));
+    }
+  });
+  test('refresh type timers set event listeners', () => {
+    // eslint-disable-next-line
+    let ee = {
+      on: jest.fn().mockImplementation((evt, cb) => {
+        cb([{
+          type: 'click'
+        }]);
+      })
+    };
+    let it = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn(),
+      ee
+    }, 100);
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1);
+    expect(it.onRefresh).toHaveBeenCalledTimes(1);
+
+    // eslint-disable-next-line
+    ee = {
+      on: jest.fn().mockImplementation((evt, cb) => {
+        cb([{
+          type: 'scroll'
+        }]);
+      })
+    };
+    it = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn(),
+      ee
+    }, 100);
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1);
+    expect(it.onRefresh).toHaveBeenCalledTimes(1);
+
+    // eslint-disable-next-line
+    ee = {
+      on: jest.fn().mockImplementation((evt, cb) => {
+        cb([{
+          type: 'keydown'
+        }]);
+      })
+    };
+    it = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn(),
+      ee
+    }, 100);
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1);
+    expect(it.onRefresh).toHaveBeenCalledTimes(1);
+    const aelSpy = jest.spyOn(document, 'addEventListener');
+    // eslint-disable-next-line
+    ee = {
+      on: jest.fn().mockImplementation((evt, cb) => {
+        cb([{
+          type: 'keydown'
+        }]);
+      })
+    };
+    it = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn(),
+      ee
+    }, 100);
+    // visibility change
+    expect(aelSpy).toHaveBeenCalledTimes(1);
+  });
+});
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.timer).toBeTruthy();
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    jest.runOnlyPendingTimers();
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+  });
+  test('Create can fallback to use defaults', () => {
+    let called = 0;
+    const timer1 = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    timer1.create();
+    const timer2 = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    timer2.create(timer2.onEnd);
+    const timer3 = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    timer3.create(undefined, 100);
+    jest.runAllTimers(200);
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1);
+  });
+});
+describe('refresh()', () => {
+  test('refresh prevents the callback from firing', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    jest.advanceTimersByTime(75);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.refresh();
+    jest.advanceTimersByTime(75);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    jest.advanceTimersByTime(100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+  });
+  test('refresh executes a callback for consumers', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn()
+    }, 100);
+    timer.refresh();
+    expect(timer.onRefresh).toHaveBeenCalledTimes(1);
+  });
+});
+describe('pause()', () => {
+  test('pause prevents the callback from firing', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.pause();
+    jest.advanceTimersByTime(150);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+  });
+  test('pause sets remainingMs timestamp', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.remainingMs).toEqual(undefined);
+    timer.pause();
+    expect(timer.remainingMs).toEqual(timer.initialMs - (now - timer.startTimestamp));
+  });
+});
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.clear();
+    jest.advanceTimersByTime(150);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    expect(timer.timer).toEqual(null);
+  });
+});
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.end();
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer.timer).toEqual(null);
+  });
+});
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.isValid()).toEqual(true);
+    timer.startTimestamp -= 100;
+    expect(timer.isValid()).toEqual(false);
+  });
+});

package/dist/cjs/common/timer/timer.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Timer = void 0;
+class Timer {
+  constructor(opts, ms) {
+    if (!opts.onEnd) throw new Error('onEnd handler is required');
+    if (!ms) throw new Error('ms duration is required');
+    this.onEnd = opts.onEnd;
+    this.initialMs = ms;
+    this.startTimestamp = Date.now();
+    this.timer = this.create(this.onEnd, ms);
+  }
+  create(cb, ms) {
+    if (this.timer) this.clear();
+    return setTimeout(() => cb ? cb() : this.onEnd(), ms || this.initialMs);
+  }
+  clear() {
+    clearTimeout(this.timer);
+    this.timer = null;
+  }
+  end() {
+    this.clear();
+    this.onEnd();
+  }
+  isValid() {
+    return this.initialMs - (Date.now() - this.startTimestamp) > 0;
+  }
+}
+exports.Timer = Timer;

package/dist/cjs/common/timer/timer.test.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var _timer = require("./timer");
+jest.useFakeTimers();
+let now;
+beforeEach(() => {
+  now = Date.now();
+  jest.setSystemTime(now);
+});
+afterEach(() => {
+  jest.clearAllMocks();
+});
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
+  });
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
+  });
+  test('required keys are enforced', () => {
+    try {
+      new _timer.Timer({}, 100);
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'));
+    }
+    try {
+      new _timer.Timer({
+        onEnd: jest.fn()
+      });
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'));
+    }
+  });
+});
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.timer).toBeTruthy();
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    jest.runOnlyPendingTimers();
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+  });
+  test('Create can fallback to use defaults', () => {
+    let called = 0;
+    const timer1 = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    timer1.create();
+    const timer2 = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    timer2.create(timer2.onEnd);
+    const timer3 = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    timer3.create(undefined, 100);
+    jest.runAllTimers(200);
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1);
+  });
+});
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.clear();
+    jest.advanceTimersByTime(150);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    expect(timer.timer).toEqual(null);
+  });
+});
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.end();
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer.timer).toEqual(null);
+  });
+});
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.isValid()).toEqual(true);
+    timer.startTimestamp -= 100;
+    expect(timer.isValid()).toEqual(false);
+  });
+});

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