@newrelic/browser-agent 0.0.9 → 0.1.229

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

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateRandomHexString = generateRandomHexString;
+exports.generateSpanId = generateSpanId;
+exports.generateTraceId = generateTraceId;
+exports.generateUuid = generateUuid;
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function generateUuid() {
+  var randomVals = null;
+  var rvIndex = 0;
+  var crypto = _globalScope.globalScope?.crypto || _globalScope.globalScope?.msCrypto;
+  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;
+    }
+  }
+
+  // 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') {
+      // 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);
+    } else {
+      id += c;
+    }
+  }
+  return id;
+}
+
+// 16-character hex string (per DT spec)
+function generateSpanId() {
+  return generateRandomHexString(16);
+}
+
+// 32-character hex string (per DT spec)
+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/metrics/framework-detection.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFrameworks = getFrameworks;
+var _globalScope = require("../util/global-scope");
+var FRAMEWORKS = {
+  REACT: 'React',
+  ANGULAR: 'Angular',
+  ANGULARJS: 'AngularJS',
+  BACKBONE: 'Backbone',
+  EMBER: 'Ember',
+  VUE: 'Vue',
+  METEOR: 'Meteor',
+  ZEPTO: 'Zepto',
+  JQUERY: 'Jquery'
+};
+function getFrameworks() {
+  if (!_globalScope.isBrowserScope) return []; // don't bother detecting frameworks if not in the main window context
+
+  var frameworks = [];
+  try {
+    if (detectReact()) frameworks.push(FRAMEWORKS.REACT);
+    if (detectAngularJs()) frameworks.push(FRAMEWORKS.ANGULARJS);
+    if (detectAngular()) frameworks.push(FRAMEWORKS.ANGULAR);
+    if (window.Backbone) frameworks.push(FRAMEWORKS.BACKBONE);
+    if (window.Ember) frameworks.push(FRAMEWORKS.EMBER);
+    if (window.Vue) frameworks.push(FRAMEWORKS.VUE);
+    if (window.Meteor) frameworks.push(FRAMEWORKS.METEOR);
+    if (window.Zepto) frameworks.push(FRAMEWORKS.ZEPTO);
+    if (window.jQuery) frameworks.push(FRAMEWORKS.JQUERY);
+  } catch (err) {
+    // not supported?
+  }
+  return frameworks;
+}
+function detectReact() {
+  try {
+    if (!!window.React || !!window.ReactDOM || !!window.ReactRedux) return true;
+    if (document.querySelector('[data-reactroot], [data-reactid]')) return true;
+    var divs = document.querySelectorAll('body > div');
+    for (var i = 0; i < divs.length; i++) {
+      if (Object.keys(divs[i]).indexOf('_reactRootContainer') >= 0) return true;
+    }
+    return false;
+  } catch (err) {
+    // not supported?
+    return false;
+  }
+}
+function detectAngularJs() {
+  try {
+    if (window.angular) return true;
+    if (document.querySelector('.ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]')) return true;
+    if (document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]')) return true;
+    return false;
+  } catch (err) {
+    // not supported?
+    return false;
+  }
+}
+function detectAngular() {
+  try {
+    // eslint-disable-next-line
+    if (window.hasOwnProperty('ng') && window.ng.hasOwnProperty('coreTokens') && window.ng.coreTokens.hasOwnProperty('NgZone')) return true;
+    return !!document.querySelectorAll('[ng-version]').length;
+  } catch (err) {
+    // not supported?
+    return false;
+  }
+}

package/dist/cjs/common/metrics/paint-metrics.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.paintMetrics = void 0;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const paintMetrics = {};
+exports.paintMetrics = paintMetrics;

package/dist/cjs/common/serialize/bel-serializer.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addCustomAttributes = addCustomAttributes;
+exports.getAddStringContext = getAddStringContext;
+exports.nullable = nullable;
+exports.numeric = numeric;
+var _mapOwn = require("../util/map-own");
+var _stringify = require("../util/stringify");
+var _obfuscate = require("../util/obfuscate");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var hasOwnProp = Object.prototype.hasOwnProperty;
+var MAX_ATTRIBUTES = 64;
+function nullable(val, fn, comma) {
+  return val || val === 0 || val === '' ? fn(val) + (comma ? ',' : '') : '!';
+}
+function numeric(n, noDefault) {
+  if (noDefault) {
+    return Math.floor(n).toString(36);
+  }
+  return n === undefined || n === 0 ? '' : Math.floor(n).toString(36);
+}
+function getAddStringContext(agentIdentifier) {
+  // eslint-disable-next-line
+  var stringTable = Object.hasOwnProperty('create') ? Object.create(null) : {};
+  var stringTableIdx = 0;
+  return addString;
+  function addString(str) {
+    if (typeof str === 'undefined' || str === '') return '';
+    var obfuscator = new _obfuscate.Obfuscator({
+      agentIdentifier: agentIdentifier
+    });
+    str = String(str);
+    if (obfuscator.shouldObfuscate()) str = obfuscator.obfuscateString(str);
+    if (hasOwnProp.call(stringTable, str)) {
+      return numeric(stringTable[str], true);
+    } else {
+      stringTable[str] = stringTableIdx++;
+      return quoteString(str);
+    }
+  }
+}
+function addCustomAttributes(attrs, addString) {
+  var attrParts = [];
+  (0, _mapOwn.mapOwn)(attrs, function (key, val) {
+    if (attrParts.length >= MAX_ATTRIBUTES) return;
+    var type = 5;
+    var serializedValue;
+    // add key to string table first
+    key = addString(key);
+    switch (typeof val) {
+      case 'object':
+        if (val) {
+          // serialize objects to strings
+          serializedValue = addString((0, _stringify.stringify)(val));
+        } else {
+          // null attribute type
+          type = 9;
+        }
+        break;
+      case 'number':
+        type = 6;
+        // make sure numbers contain a `.` so they are parsed as doubles
+        serializedValue = val % 1 ? val : val + '.';
+        break;
+      case 'boolean':
+        type = val ? 7 : 8;
+        break;
+      case 'undefined':
+        // we treat undefined as a null attribute (since dirac does not have a concept of undefined)
+        type = 9;
+        break;
+      default:
+        serializedValue = addString(val);
+    }
+    attrParts.push([type, key + (serializedValue ? ',' + serializedValue : '')]);
+  });
+  return attrParts;
+}
+var escapable = /([,\\;])/g;
+function quoteString(str) {
+  return "'" + str.replace(escapable, '\\$1');
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addPN = addPN;
+exports.addPT = addPT;
+exports.addRel = addRel;
+exports.navTimingValues = void 0;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// We don't use JSON.stringify directly on the performance timing data for these reasons:
+// * Chrome has extra data in the performance object that we don't want to send all the time (wasteful)
+// * Firefox fails to stringify the native object due to - http://code.google.com/p/v8/issues/detail?id=1223
+// * The variable names are long and wasteful to transmit
+
+// Add Performance Timing values to the given object.
+// * Values are written relative to an offset to reduce their length (i.e. number of characters).
+// * The offset is sent with the data
+// * 0's are not included unless the value is a 'relative zero'
+//
+
+var START = 'Start';
+var END = 'End';
+var UNLOAD_EVENT = 'unloadEvent';
+var REDIRECT = 'redirect';
+var DOMAIN_LOOKUP = 'domainLookup';
+var ONNECT = 'onnect';
+var REQUEST = 'request';
+var RESPONSE = 'response';
+var LOAD_EVENT = 'loadEvent';
+var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent';
+var navTimingValues = [];
+exports.navTimingValues = navTimingValues;
+function addPT(offset, pt, v) {
+  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');
+  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');
+  return v;
+}
+function addRel(value, offset, obj, prop) {
+  var relativeValue;
+  if (typeof value === 'number' && value > 0) {
+    relativeValue = Math.max(Math.round(value - offset), 0);
+    obj[prop] = relativeValue;
+  }
+  navTimingValues.push(relativeValue);
+}

package/dist/cjs/common/timing/now.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.now = now;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// This is our own layer around performance.now. It's not strictly necessary, but we keep it in case of future mod-ing of the value for refactor purpose.
+function now() {
+  return Math.round(performance.now());
+}

package/dist/cjs/common/unload/eol.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeToEOL = subscribeToEOL;
+var _firefoxVersion = require("../browser-version/firefox-version");
+var _eventListenerOpts = require("../event-listener/event-listener-opts");
+var _single = require("../util/single");
+var _globalScope = require("../util/global-scope");
+var _pageVisibility = require("../window/page-visibility");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+if (_globalScope.isWorkerScope) {
+  _globalScope.globalScope.cleanupTasks = []; // create new list on WorkerGlobalScope to track funcs to run before exiting thread
+
+  const origClose = _globalScope.globalScope.close;
+  _globalScope.globalScope.close = () => {
+    // on worker's EoL signal, execute all "listeners", e.g. final harvests
+    for (let task of _globalScope.globalScope.cleanupTasks) {
+      task();
+    }
+    origClose();
+  };
+}
+
+/**
+ * Subscribes a provided callback to the time/event when the agent should treat it as end-of-life.
+ * This is used, for example, to submit a final harvest and send all remaining data on best-effort.
+ * @param {function} cb - func to run before or during the last reliable event or time of an env's life span
+ * @param {boolean} allowBFCache - (temp) feature flag to gate new v1222 BFC support
+ */
+function subscribeToEOL(cb, allowBFCache) {
+  if (_globalScope.isBrowserScope) {
+    if (allowBFCache) {
+      (0, _pageVisibility.subscribeToVisibilityChange)(cb, true); // when user switches tab or hides window, esp. mobile scenario
+      (0, _eventListenerOpts.windowAddEventListener)('pagehide', cb); // when user navigates away, and because safari iOS v14.4- doesn't fully support vis change
+      // --this ought to be removed once support for version below 14.5 phases out
+    } else {
+      var oneCall = (0, _single.single)(cb);
+
+      // Firefox has a bug wherein a slow-loading resource loaded from the 'pagehide'
+      // or 'unload' event will delay the 'load' event firing on the next page load.
+      // In Firefox versions that support sendBeacon, this doesn't matter, because
+      // we'll use it instead of an image load for our final harvest.
+      //
+      // Some Safari versions never fire the 'unload' event for pages that are being
+      // put into the WebKit page cache, so we *need* to use the pagehide event for
+      // the final submission from Safari.
+      //
+      // Generally speaking, we will try to submit our final harvest from either
+      // pagehide or unload, whichever comes first, but in Firefox, we need to avoid
+      // attempting to submit from pagehide to ensure that we don't slow down loading
+      // of the next page.
+      if (!_firefoxVersion.ffVersion || navigator.sendBeacon) {
+        (0, _eventListenerOpts.windowAddEventListener)('pagehide', oneCall);
+      } else {
+        (0, _eventListenerOpts.windowAddEventListener)('beforeunload', oneCall);
+      }
+      (0, _eventListenerOpts.windowAddEventListener)('unload', oneCall);
+    }
+  } else if (_globalScope.isWorkerScope) {
+    _globalScope.globalScope.cleanupTasks.push(cb); // close() should run these tasks before quitting thread
+  }
+  // By default (for other env), this fn has no effect.
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanURL = cleanURL;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var withHash = /([^?#]*)[^#]*(#[^?]*|$).*/;
+var withoutHash = /([^?#]*)().*/;
+function cleanURL(url, keepHash) {
+  return url.replace(keepHash ? withHash : withoutHash, '$1$2');
+}

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

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fromArray = fromArray;
+exports.obj = obj;
+exports.param = param;
+exports.qs = qs;
+var _mapOwn = require("../util/map-own");
+var _stringify = require("../util/stringify");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Characters that are safe in a qs, but get encoded.
+var charMap = {
+  '%2C': ',',
+  '%3A': ':',
+  '%2F': '/',
+  '%40': '@',
+  '%24': '$',
+  '%3B': ';'
+};
+var charList = (0, _mapOwn.mapOwn)(charMap, function (k) {
+  return k;
+});
+var safeEncoded = new RegExp(charList.join('|'), 'g');
+function real(c) {
+  return charMap[c];
+}
+
+// Encode as URI Component, then unescape anything that is ok in the
+// query string position.
+function qs(value) {
+  if (value === null || value === undefined) return 'null';
+  return encodeURIComponent(value).replace(safeEncoded, real);
+}
+function fromArray(qs, maxBytes) {
+  var bytes = 0;
+  for (var i = 0; i < qs.length; i++) {
+    bytes += qs[i].length;
+    if (bytes > maxBytes) return qs.slice(0, i).join('');
+  }
+  return qs.join('');
+}
+function obj(payload, maxBytes) {
+  var total = 0;
+  var result = '';
+  (0, _mapOwn.mapOwn)(payload, function (feature, dataArray) {
+    var intermediate = [];
+    var next;
+    var i;
+    if (typeof dataArray === 'string') {
+      next = '&' + feature + '=' + qs(dataArray);
+      total += next.length;
+      result += next;
+    } else if (dataArray.length) {
+      total += 9;
+      for (i = 0; i < dataArray.length; i++) {
+        next = qs((0, _stringify.stringify)(dataArray[i]));
+        total += next.length;
+        if (typeof maxBytes !== 'undefined' && total >= maxBytes) break;
+        intermediate.push(next);
+      }
+      result += '&' + feature + '=%5B' + intermediate.join(',') + '%5D';
+    }
+  });
+  return result;
+}
+
+// Constructs an HTTP parameter to add to the BAM router URL
+function param(name, value) {
+  if (value && typeof value === 'string') {
+    return '&' + name + '=' + qs(value);
+  }
+  return '';
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLocation = getLocation;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function getLocation() {
+  return '' + location;
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseUrl = parseUrl;
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var stringsToParsedUrls = {};
+function parseUrl(url) {
+  if (url in stringsToParsedUrls) {
+    return stringsToParsedUrls[url];
+  }
+
+  // Return if URL is a data URL, parseUrl assumes urls are http/https
+  if ((url || '').indexOf('data:') === 0) {
+    return {
+      protocol: 'data'
+    };
+  }
+  let urlEl;
+  var location = _globalScope.globalScope?.location;
+  var ret = {};
+  if (_globalScope.isBrowserScope) {
+    // Use an anchor dom element to resolve the url natively.
+    urlEl = document.createElement('a');
+    urlEl.href = url;
+  } else {
+    try {
+      urlEl = new URL(url, location.href);
+    } catch (err) {
+      return ret;
+    }
+  }
+  ret.port = urlEl.port;
+  var firstSplit = urlEl.href.split('://');
+  if (!ret.port && firstSplit[1]) {
+    ret.port = firstSplit[1].split('/')[0].split('@').pop().split(':')[1];
+  }
+  if (!ret.port || ret.port === '0') ret.port = firstSplit[0] === 'https' ? '443' : '80';
+
+  // Host not provided in IE for relative urls
+  ret.hostname = urlEl.hostname || location.hostname;
+  ret.pathname = urlEl.pathname;
+  ret.protocol = firstSplit[0];
+
+  // Pathname sometimes doesn't have leading slash (IE 8 and 9)
+  if (ret.pathname.charAt(0) !== '/') ret.pathname = '/' + ret.pathname;
+
+  // urlEl.protocol is ':' in old ie when protocol is not specified
+  var sameProtocol = !urlEl.protocol || urlEl.protocol === ':' || urlEl.protocol === location.protocol;
+  var sameDomain = urlEl.hostname === location.hostname && urlEl.port === location.port;
+
+  // urlEl.hostname is not provided by IE for relative urls, but relative urls are also same-origin
+  ret.sameOrigin = sameProtocol && (!urlEl.hostname || sameDomain);
+
+  // Only cache if url doesn't have a path
+  if (ret.pathname === '/') {
+    stringsToParsedUrls[url] = ret;
+  }
+  return ret;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.protocol = void 0;
+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;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.warn = warn;
+/**
+ * A helper method to warn to the console with New Relic: decoration
+ * @param {string} message - The primary message to warn
+ * @param {*} secondary - Secondary data to include, usually an error or object
+ * @returns
+ */
+function warn(message, secondary) {
+  if (!console || !console.warn || typeof console.warn !== 'function') return;
+  console.warn(`New Relic: ${message}`);
+  if (secondary) console.warn(secondary);
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dataSize = dataSize;
+var _stringify = require("./stringify");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function dataSize(data) {
+  if (typeof data === 'string' && data.length) return data.length;
+  if (typeof data !== 'object') return undefined;
+  // eslint-disable-next-line
+  if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer && data.byteLength) return data.byteLength;
+  if (typeof Blob !== 'undefined' && data instanceof Blob && data.size) return data.size;
+  if (typeof FormData !== 'undefined' && data instanceof FormData) return undefined;
+  try {
+    return (0, _stringify.stringify)(data).length;
+  } catch (e) {
+    return undefined;
+  }
+}