@newrelic/browser-agent 0.0.9 → 0.1.230

package/dist/cjs/common/event-emitter/contextual-ee.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ee = void 0;
+exports.getOrSetContext = getOrSetContext;
+var _nreum = require("../window/nreum");
+var _getOrSet = require("../util/get-or-set");
+var _mapOwn = require("../util/map-own");
+var _config = require("../config/config");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var ctxId = 'nr@context';
+
+// create global emitter instance that can be shared among bundles
+let nr = (0, _nreum.gosNREUM)();
+var globalInstance;
+exports.ee = globalInstance;
+if (nr.ee) {
+  exports.ee = globalInstance = nr.ee;
+} else {
+  exports.ee = globalInstance = ee(undefined, 'globalEE');
+  nr.ee = globalInstance;
+}
+function EventContext() {}
+function ee(old, debugId) {
+  var handlers = {};
+  var bufferGroupMap = {};
+  var emitters = {};
+  // In cases where multiple agents can run on a page, the event backlogs of feature event emitters must be isolated
+  // to prevent event emitter context and buffers from "bubbling up" to other agents operating in the scope.
+  // An example of this is our MicroAgent loader package, which sets this property to true to prevent overlap.
+  var isolatedBacklog = false;
+  try {
+    // We only want to check the runtime configuration for `isolatedBacklog` if the event emitter belongs to a feature.
+    // For feature event emitters, the debugId will be an agentIdentifier with a length of 16. In contrast, some of our
+    // tests do not namespace the event emitter with an agentID and just use the parent (which has no ID).
+    isolatedBacklog = debugId.length !== 16 ? false : (0, _config.getRuntime)(debugId).isolatedBacklog;
+  } catch (err) {
+    // Do nothing for now.
+  }
+  var emitter = {
+    on: addEventListener,
+    addEventListener: addEventListener,
+    removeEventListener: removeEventListener,
+    emit: emit,
+    get: getOrCreate,
+    listeners: listeners,
+    context: context,
+    buffer: bufferEventsByGroup,
+    abort,
+    aborted: false,
+    isBuffering: isBuffering,
+    debugId,
+    backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {}
+  };
+  return emitter;
+  function context(contextOrStore) {
+    if (contextOrStore && contextOrStore instanceof EventContext) {
+      return contextOrStore;
+    } else if (contextOrStore) {
+      return (0, _getOrSet.getOrSet)(contextOrStore, ctxId, getNewContext);
+    } else {
+      return getNewContext();
+    }
+  }
+  function emit(type, args, contextOrStore, force, bubble) {
+    if (bubble !== false) bubble = true;
+    if (globalInstance.aborted && !force) {
+      return;
+    }
+    if (old && bubble) old.emit(type, args, contextOrStore);
+    var ctx = context(contextOrStore);
+    var handlersArray = listeners(type);
+    var len = handlersArray.length;
+
+    // Apply each handler function in the order they were added
+    // to the context with the arguments
+
+    for (var i = 0; i < len; i++) handlersArray[i].apply(ctx, args);
+
+    // Buffer after emitting for consistent ordering
+    var bufferGroup = getBuffer()[bufferGroupMap[type]];
+    if (bufferGroup) {
+      bufferGroup.push([emitter, type, args, ctx]);
+    }
+
+    // Return the context so that the module that emitted can see what was done.
+    return ctx;
+  }
+  function addEventListener(type, fn) {
+    // Retrieve type from handlers, if it doesn't exist assign the default and retrieve it.
+    handlers[type] = listeners(type).concat(fn);
+  }
+  function removeEventListener(type, fn) {
+    var listeners = handlers[type];
+    if (!listeners) return;
+    for (var i = 0; i < listeners.length; i++) {
+      if (listeners[i] === fn) {
+        listeners.splice(i, 1);
+      }
+    }
+  }
+  function listeners(type) {
+    return handlers[type] || [];
+  }
+  function getOrCreate(name) {
+    return emitters[name] = emitters[name] || ee(emitter, name);
+  }
+  function bufferEventsByGroup(types, group) {
+    var eventBuffer = getBuffer();
+
+    // do not buffer events if agent has been aborted
+    if (emitter.aborted) return;
+    (0, _mapOwn.mapOwn)(types, function (i, type) {
+      group = group || 'feature';
+      bufferGroupMap[type] = group;
+      if (!(group in eventBuffer)) {
+        eventBuffer[group] = [];
+      }
+    });
+  }
+  function isBuffering(type) {
+    var bufferGroup = getBuffer()[bufferGroupMap[type]];
+    return !!bufferGroup;
+  }
+
+  // buffer is associated with a base emitter, since there are two
+  // (global and scoped to the current bundle), it is now part of the emitter
+  function getBuffer() {
+    return emitter.backlog;
+  }
+}
+
+// get context object from store object, or create if does not exist
+function getOrSetContext(obj) {
+  return (0, _getOrSet.getOrSet)(obj, ctxId, getNewContext);
+}
+function getNewContext() {
+  return new EventContext();
+}
+function abort() {
+  globalInstance.aborted = true;
+  globalInstance.backlog = {};
+}

package/dist/cjs/common/event-emitter/handle.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handle = handle;
+exports.handleEE = void 0;
+var _contextualEe = require("./contextual-ee");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var handleEE = _contextualEe.ee.get('handle');
+exports.handleEE = handleEE;
+function handle(type, args, ctx, group, ee) {
+  if (ee) {
+    ee.buffer([type], group);
+    ee.emit(type, args, ctx);
+  } else {
+    handleEE.buffer([type], group);
+    handleEE.emit(type, args, ctx);
+  }
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultRegister = exports.registerHandler = defaultRegister;
+var _handle = require("./handle");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+defaultRegister.on = registerWithSpecificEmitter;
+var handlers = defaultRegister.handlers = {};
+function defaultRegister(type, handler, group, ee) {
+  registerWithSpecificEmitter(ee || _handle.handleEE, handlers, type, handler, group);
+}
+function registerWithSpecificEmitter(ee, handlers, type, handler, group) {
+  if (!group) group = 'feature';
+  if (!ee) ee = _handle.handleEE;
+  var groupHandlers = handlers[group] = handlers[group] || {};
+  var list = groupHandlers[type] = groupHandlers[type] || [];
+  list.push([ee, handler]);
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.documentAddEventListener = documentAddEventListener;
+exports.eventListenerOpts = eventListenerOpts;
+exports.windowAddEventListener = windowAddEventListener;
+var _globalScope = require("../util/global-scope");
+/*
+ * See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#safely_detecting_option_support
+ */
+let passiveSupported = false;
+let signalSupported = false;
+try {
+  const options = {
+    get passive() {
+      // this function will be called when the browser attempts to access the passive property
+      passiveSupported = true;
+      return false;
+    },
+    get signal() {
+      signalSupported = true;
+      return false;
+    }
+  };
+  _globalScope.globalScope.addEventListener('test', null, options);
+  _globalScope.globalScope.removeEventListener('test', null, options);
+} catch (err) {}
+function eventListenerOpts(useCapture, abortSignal) {
+  return passiveSupported || signalSupported ? {
+    capture: !!useCapture,
+    passive: passiveSupported,
+    // passive defaults to false
+    signal: abortSignal
+  } : !!useCapture; // mainly just IE11 doesn't support third param options under EventTarget API
+}
+
+/** Do not use this within the worker context. */
+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) {
+  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

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HarvestScheduler = void 0;
+var _submitData = require("../util/submit-data");
+var _sharedContext = require("../context/shared-context");
+var _harvest = require("./harvest");
+var _eol = require("../unload/eol");
+var _config = require("../config/config");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Periodically invokes harvest calls and handles retries
+ */
+class HarvestScheduler extends _sharedContext.SharedContext {
+  constructor(endpoint, opts, parent) {
+    super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
+    this.endpoint = endpoint;
+    this.opts = opts || {};
+    this.started = false;
+    this.timeoutHandle = null;
+    this.aborted = false; // this controls the per-interval and final harvests for the scheduler (currently per feature specific!)
+
+    this.harvest = new _harvest.Harvest(this.sharedContext);
+    (0, _eol.subscribeToEOL)(() => {
+      if (this.aborted) return;
+
+      // If opts.onUnload is defined, these are special actions to execute before attempting to send the final payload.
+      if (this.opts.onUnload) this.opts.onUnload();
+      this.runHarvest({
+        unload: true
+      });
+    }, (0, _config.getConfigurationValue)(this.sharedContext.agentIdentifier, 'allow_bfcache')); // TO DO: remove feature flag after rls stable
+  }
+
+  startTimer(interval, initialDelay) {
+    this.interval = interval;
+    this.started = true;
+    this.scheduleHarvest(initialDelay != null ? initialDelay : this.interval);
+  }
+  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) {
+      clearTimeout(this.timeoutHandle);
+    }
+  }
+  scheduleHarvest(delay, opts) {
+    if (this.timeoutHandle) return;
+    var timer = this;
+    if (delay == null) {
+      delay = this.interval;
+    }
+    this.timeoutHandle = setTimeout(() => {
+      timer.timeoutHandle = null;
+      timer.runHarvest(opts);
+    }, delay * 1000);
+  }
+  runHarvest(opts) {
+    if (this.aborted) return;
+    var scheduler = this;
+    if (this.opts.getPayload) {
+      // Ajax & PVT
+      var submitMethod = (0, _harvest.getSubmitMethod)(this.endpoint, opts);
+      if (!submitMethod) return false;
+      var retry = submitMethod.method === _submitData.submitData.xhr;
+      var payload = this.opts.getPayload({
+        retry: retry
+      });
+      if (payload) {
+        payload = Object.prototype.toString.call(payload) === '[object Array]' ? payload : [payload];
+        for (var i = 0; i < payload.length; i++) {
+          this.harvest.send(this.endpoint, payload[i], opts, submitMethod, onHarvestFinished);
+        }
+      }
+    } else {
+      const runAfterSending = opts?.unload ? undefined : onHarvestFinished; // don't bother running onFinish handler if this is the final harvest
+      this.harvest.sendX(this.endpoint, opts, runAfterSending);
+    }
+    if (this.started) {
+      this.scheduleHarvest();
+    }
+    return;
+    function onHarvestFinished(result) {
+      if (result.blocked) scheduler.onHarvestBlocked(opts, result);else scheduler.onHarvestFinished(opts, result);
+    }
+  }
+  onHarvestFinished(opts, result) {
+    if (this.opts.onFinished) {
+      this.opts.onFinished(result);
+    }
+    if (result.sent && result.retry) {
+      var delay = result.delay || this.opts.retryDelay;
+      // reschedule next harvest if should be delayed longer
+      if (this.started && delay) {
+        clearTimeout(this.timeoutHandle);
+        this.timeoutHandle = null;
+        this.scheduleHarvest(delay, opts);
+      } else if (!this.started && delay) {
+        // if not running on a timer, schedule a single retry
+        this.scheduleHarvest(delay, opts);
+      }
+    }
+  }
+}
+exports.HarvestScheduler = HarvestScheduler;

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

@@ -0,0 +1,247 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Harvest = void 0;
+exports.getSubmitMethod = getSubmitMethod;
+var _mapOwn = require("../util/map-own");
+var _encode = require("../url/encode");
+var _stringify = require("../util/stringify");
+var _submitData = require("../util/submit-data");
+var _location = require("../url/location");
+var _config = require("../config/config");
+var _cleanUrl = require("../url/clean-url");
+var _now = require("../timing/now");
+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 _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const haveSendBeacon = !!navigator.sendBeacon; // only the web window obj has sendBeacon at this time, so 'false' for other envs
+
+class Harvest extends _sharedContext.SharedContext {
+  constructor(parent) {
+    super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
+
+    this.tooManyRequestsDelay = (0, _config.getConfigurationValue)(this.sharedContext.agentIdentifier, 'harvest.tooManyRequestsDelay') || 60;
+    this.obfuscator = new _obfuscate.Obfuscator(this.sharedContext);
+    this.getScheme = () => (0, _config.getConfigurationValue)(this.sharedContext.agentIdentifier, 'ssl') === false ? 'http' : 'https';
+    this._events = {};
+  }
+
+  /**
+   * Initiate a harvest from multiple sources. An event that corresponds to the endpoint
+   * name is emitted, which gives any listeners the opportunity to provide payload data.
+   *
+   * @param {string} endpoint - The endpoint of the harvest (jserrors, events, resources etc.)
+   *
+   * @param {object} opts
+   * @param {bool} opts.needResponse - Specify whether the caller expects a response data.
+   * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
+   */
+  sendX(endpoint, opts, cbFinished) {
+    var submitMethod = getSubmitMethod(endpoint, opts);
+    if (!submitMethod) return false;
+    var options = {
+      retry: submitMethod.method === _submitData.submitData.xhr
+    };
+    return this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend(endpoint, this.createPayload(endpoint, options), opts, submitMethod, cbFinished) : this._send(endpoint, this.createPayload(endpoint, options), opts, submitMethod, cbFinished);
+  }
+
+  /**
+  * Initiate a harvest call.
+  *
+  * @param {string} endpoint - The endpoint of the harvest (jserrors, events, resources etc.)
+  * @param {object} nr - The loader singleton.
+  *
+  * @param {object} singlePayload - Object representing payload.
+  * @param {object} singlePayload.qs - Map of values that should be sent as part of the request query string.
+  * @param {string} singlePayload.body - String that should be sent as the body of the request.
+  * @param {string} singlePayload.body.e - Special case of body used for browser interactions.
+  *
+  * @param {object} opts
+  * @param {bool} opts.needResponse - Specify whether the caller expects a response data.
+  * @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);
+    if (singlePayload.qs) (0, _mapOwn.mapOwn)(singlePayload.qs, makeQueryString);
+    var payload = {
+      body: makeBody(),
+      qs: makeQueryString()
+    };
+    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) {
+    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) {
+    var info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
+    if (!info.errorBeacon) return false;
+    var agentRuntime = (0, _config.getRuntime)(this.sharedContext.agentIdentifier);
+    if (!payload.body) {
+      // no payload body? nothing to send, just run onfinish stuff and return
+      if (cbFinished) {
+        cbFinished({
+          sent: false
+        });
+      }
+      return false;
+    }
+    if (!opts) opts = {};
+    var url = this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + this.baseQueryString();
+    if (payload.qs) url += (0, _encode.obj)(payload.qs, agentRuntime.maxBytes);
+    if (!submitMethod) {
+      submitMethod = getSubmitMethod(endpoint, opts);
+    }
+    var method = submitMethod.method;
+    var useBody = submitMethod.useBody;
+    var body;
+    var fullUrl = url;
+    if (useBody && endpoint === 'events') {
+      body = payload.body.e;
+    } else if (useBody) {
+      body = (0, _stringify.stringify)(payload.body);
+    } else {
+      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. */
+    var result = method(fullUrl, body, opts.unload && _globalScope.isWorkerScope);
+    if (cbFinished && method === _submitData.submitData.xhr) {
+      var xhr = result;
+      xhr.addEventListener('load', function () {
+        var result = {
+          sent: true
+        };
+        if (this.status === 429) {
+          result.retry = true;
+          result.delay = this.tooManyRequestsDelay;
+        } else if (this.status === 408 || this.status === 500 || this.status === 503) {
+          result.retry = true;
+        }
+        if (opts.needResponse) {
+          result.responseText = this.responseText;
+        }
+        cbFinished(result);
+      }, (0, _eventListenerOpts.eventListenerOpts)(false));
+    }
+
+    // if beacon request failed, retry with an alternative method -- will not happen for workers
+    if (!result && method === _submitData.submitData.beacon) {
+      method = _submitData.submitData.img;
+      result = method(url + (0, _encode.obj)(payload.body, agentRuntime.maxBytes));
+    }
+    return result;
+  }
+
+  // The stuff that gets sent every time.
+  baseQueryString() {
+    var runtime = (0, _config.getRuntime)(this.sharedContext.agentIdentifier);
+    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',
+    // ck param DEPRECATED - still expected by backend
+    '&s=' + (runtime.sessionId || '0'),
+    // the 0 id encaps all untrackable and default traffic
+    (0, _encode.param)('ref', ref), (0, _encode.param)('ptid', runtime.ptid ? '' + runtime.ptid : '')].join('');
+  }
+  createPayload(type, options) {
+    var makeBody = createAccumulator();
+    var makeQueryString = createAccumulator();
+    var listeners = this._events[type] && this._events[type] || [];
+    for (var i = 0; i < listeners.length; i++) {
+      var singlePayload = listeners[i](options);
+      if (!singlePayload) continue;
+      if (singlePayload.body) (0, _mapOwn.mapOwn)(singlePayload.body, makeBody);
+      if (singlePayload.qs) (0, _mapOwn.mapOwn)(singlePayload.qs, makeQueryString);
+    }
+    return {
+      body: makeBody(),
+      qs: makeQueryString()
+    };
+  }
+  on(type, listener) {
+    var listeners = this._events[type] || (this._events[type] = []);
+    listeners.push(listener);
+  }
+  resetListeners() {
+    (0, _mapOwn.mapOwn)(this._events, key => {
+      this._events[key] = [];
+    });
+  }
+}
+exports.Harvest = Harvest;
+function or(a, b) {
+  return a || b;
+}
+function getSubmitMethod(endpoint, opts) {
+  opts = opts || {};
+  var method;
+  var useBody;
+  if (opts.needResponse) {
+    // currently: only STN needs a response
+    useBody = true;
+    method = _submitData.submitData.xhr;
+  } else if (opts.unload && _globalScope.isBrowserScope) {
+    // all the features' final harvest; neither methods work outside window context
+    useBody = haveSendBeacon;
+    method = haveSendBeacon ? _submitData.submitData.beacon : _submitData.submitData.img; // really only IE doesn't have Beacon API for web browsers
+  } else {
+    // `submitData.beacon` was removed, there is an upper limit to the
+    // number of data allowed before it starts failing, so we save it only for page unloading
+    useBody = true;
+    method = _submitData.submitData.xhr;
+  }
+  return {
+    method: method,
+    useBody: useBody
+  };
+}
+
+// Constructs the transaction name param for the beacon URL.
+// Prefers the obfuscated transaction name over the plain text.
+// Falls back to making up a name.
+function transactionNameParam(info) {
+  if (info.transactionName) return (0, _encode.param)('to', info.transactionName);
+  return (0, _encode.param)('t', info.tNamePlain || 'Unnamed Transaction');
+}
+
+// returns a function that can be called to accumulate values to a single object
+// when the function is called without parameters, then the accumulator is returned
+function createAccumulator() {
+  var accumulator = {};
+  var hasData = false;
+  return function (key, val) {
+    if (val && val.length) {
+      accumulator[key] = val;
+      hasData = true;
+    }
+    if (hasData) return accumulator;
+  };
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.id = id;
+var _getOrSet = require("../util/get-or-set");
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Start assigning ids at 1 so 0 can always be used for WindowOrWorkerGlobalScope, without
+// actually setting it (which would create a global variable).
+
+var index = 1;
+var prop = 'nr@id';
+
+// Always returns id of obj, may tag obj with an id in the process.
+function id(obj) {
+  var 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;
+  if (obj === _globalScope.globalScope) return 0;
+  return (0, _getOrSet.getOrSet)(obj, prop, function () {
+    return index++;
+  });
+}