{"version":3,"sources":["node_modules/@newrelic/browser-agent/dist/esm/common/wrap/wrap-events.js","node_modules/@newrelic/browser-agent/dist/esm/common/wrap/wrap-fetch.js","node_modules/@newrelic/browser-agent/dist/esm/common/wrap/wrap-history.js","node_modules/@newrelic/browser-agent/dist/esm/common/wrap/wrap-jsonp.js","node_modules/@newrelic/browser-agent/dist/esm/common/wrap/wrap-mutation.js","node_modules/@newrelic/browser-agent/dist/esm/common/wrap/wrap-promise.js","node_modules/@newrelic/browser-agent/dist/esm/common/wrap/wrap-timer.js","node_modules/@newrelic/browser-agent/dist/esm/common/wrap/wrap-xhr.js"],"sourcesContent":["/*\n * Copyright 2020 New Relic Corporation. All rights reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * @file Wraps `addEventListener` and `removeEventListener` for instrumentation.\n * This module is used directly by: session_trace.\n * It is also called by -> wrapXhr <-, so see \"wrap-xhr.js\" for features that use this indirectly.\n */\nimport { ee as baseEE, contextId } from '../event-emitter/contextual-ee';\nimport { createWrapperWithEmitter as wfn } from './wrap-function';\nimport { getOrSet } from '../util/get-or-set';\nimport { globalScope, isBrowserScope } from '../constants/runtime';\nconst wrapped = {};\nconst XHR = globalScope.XMLHttpRequest;\nconst ADD_EVENT_LISTENER = 'addEventListener';\nconst REMOVE_EVENT_LISTENER = 'removeEventListener';\nconst flag = \"nr@wrapped:\".concat(contextId);\n\n/**\n * Wraps `addEventListener` and `removeEventListener` on: global scope; the prototype of `XMLHttpRequest`, and\n * `document` (if in a browser scope). Adds custom events in context of a new emitter scoped only to these methods.\n * @param {Object} sharedEE - The shared event emitter on which a new scoped\n *     event emitter will be based.\n * @returns {Object} Scoped event emitter with a debug ID of `events`.\n */\nexport function wrapEvents(sharedEE) {\n  var ee = scopedEE(sharedEE);\n\n  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,\n  // then we increment the count to track # of feats using this at runtime.\n  if (wrapped[ee.debugId]++) return ee;\n  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap events\n  var wrapFn = wfn(ee, true);\n\n  // Guard against instrumenting environments w/o necessary features\n  if ('getPrototypeOf' in Object) {\n    if (isBrowserScope) findEventListenerProtoAndCb(document, wrapNode);\n    findEventListenerProtoAndCb(globalScope, wrapNode);\n    findEventListenerProtoAndCb(XHR.prototype, wrapNode);\n  }\n  ee.on(ADD_EVENT_LISTENER + '-start', function (args, target) {\n    var originalListener = args[1];\n    if (originalListener === null || typeof originalListener !== 'function' && typeof originalListener !== 'object') {\n      return;\n    }\n    var wrapped = getOrSet(originalListener, flag, function () {\n      var listener = {\n        object: wrapHandleEvent,\n        function: originalListener\n      }[typeof originalListener];\n      return listener ? wrapFn(listener, 'fn-', null, listener.name || 'anonymous') : originalListener;\n      function wrapHandleEvent() {\n        if (typeof originalListener.handleEvent !== 'function') return;\n        return originalListener.handleEvent.apply(originalListener, arguments);\n      }\n    });\n    this.wrapped = args[1] = wrapped;\n  });\n  ee.on(REMOVE_EVENT_LISTENER + '-start', function (args) {\n    args[1] = this.wrapped || args[1];\n  });\n  function wrapNode(node) {\n    wrapFn.inPlace(node, [ADD_EVENT_LISTENER, REMOVE_EVENT_LISTENER], '-', uniqueListener);\n  }\n  function uniqueListener(args, obj) {\n    // Context for the listener is stored on itself.\n    return args[1];\n  }\n  return ee;\n}\n/**\n * Find the base prototype of 'object' that has its own \"addEventListener\" property, and run some function on it.\n * @param {Object} object - the initial object to traverse prototype chain on\n * @param {Function} cb - the function to run on the ancestral object once found, accepts an object as a arg\n * @param {Array} rest - [optional] any additional arguments to pass to the cb\n */\nfunction findEventListenerProtoAndCb(object, cb) {\n  let step = object;\n  while (typeof step === 'object' && !Object.prototype.hasOwnProperty.call(step, ADD_EVENT_LISTENER)) {\n    step = Object.getPrototypeOf(step);\n  }\n  for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n    rest[_key - 2] = arguments[_key];\n  }\n  if (step) cb(step, ...rest);\n}\n\n/**\n * Returns an event emitter scoped specifically for the `events` context. This scoping is a remnant from when all the\n * features shared the same group in the event, to isolate events between features. It will likely be revisited.\n * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.\n *     Uses `ee` on the global scope if undefined).\n * @returns {Object} Scoped event emitter with a debug ID of 'events'.\n */\nexport function scopedEE(sharedEE) {\n  return (sharedEE || baseEE).get('events');\n}","/*\n * Copyright 2020 New Relic Corporation. All rights reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * @file Wraps `fetch` and related methods for instrumentation.\n * This module is used by: ajax, spa.\n */\nimport { ee as baseEE, contextId } from '../event-emitter/contextual-ee';\nimport { globalScope } from '../constants/runtime';\nvar prefix = 'fetch-';\nvar bodyPrefix = prefix + 'body-';\nvar bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData'];\nvar Req = globalScope.Request;\nvar Res = globalScope.Response;\nvar proto = 'prototype';\nconst wrapped = {};\n\n/**\n * Wraps the `fetch` method of the global scope for instrumentation. Also wraps the prototypes of the async methods\n * that parse Request and Response bodies to generate start and end events for each, in context of a new event\n * emitter scoped only to fetch and related methods.\n * @param {Object} sharedEE - The shared event emitter on which a new scoped\n *     event emitter will be based.\n * @returns {Object} Scoped event emitter with a debug ID of `fetch`.\n */\nexport function wrapFetch(sharedEE) {\n  const ee = scopedEE(sharedEE);\n  if (!(Req && Res && globalScope.fetch)) {\n    return ee;\n  }\n\n  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,\n  // then we increment the count to track # of feats using this at runtime.\n  if (wrapped[ee.debugId]++) return ee;\n  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap fetch\n\n  bodyMethods.forEach(method => {\n    wrapPromiseMethod(Req[proto], method, bodyPrefix);\n    wrapPromiseMethod(Res[proto], method, bodyPrefix);\n  });\n  wrapPromiseMethod(globalScope, 'fetch', prefix);\n  ee.on(prefix + 'end', function (err, res) {\n    var ctx = this;\n    if (res) {\n      var size = res.headers.get('content-length');\n      if (size !== null) {\n        ctx.rxSize = size;\n      }\n      ee.emit(prefix + 'done', [null, res], ctx);\n    } else {\n      ee.emit(prefix + 'done', [err], ctx);\n    }\n  });\n\n  /**\n   * Wraps a Promise-returning function (referenced by `target[name]`) to emit custom events before and after\n   * execution, each decorated with metadata (arguments, payloads, errors). Used to wrap the async body\n   * parsing methods of Request and Response (e.g. `json`, `text`, `formData`).\n   * @param {Object} target - The object having the method to be wrapped.\n   * @param {string} name - The name of the method to wrap.\n   * @param {string} prefix - Used to decorate event names with context.\n   */\n  function wrapPromiseMethod(target, name, prefix) {\n    var fn = target[name];\n    if (typeof fn === 'function') {\n      target[name] = function () {\n        var args = [...arguments];\n        var ctx = {};\n        // we are wrapping args in an array so we can preserve the reference\n        ee.emit(prefix + 'before-start', [args], ctx);\n        var dtPayload;\n        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt;\n        var origPromiseFromFetch = fn.apply(this, args);\n        ee.emit(prefix + 'start', [args, dtPayload], origPromiseFromFetch);\n\n        // Note we need to cast the returned (orig) Promise from native APIs into the current global Promise, which may or may not be our WrappedPromise.\n        return origPromiseFromFetch.then(function (val) {\n          ee.emit(prefix + 'end', [null, val], origPromiseFromFetch);\n          return val;\n        }, function (err) {\n          ee.emit(prefix + 'end', [err], origPromiseFromFetch);\n          throw err;\n        });\n      };\n    }\n  }\n  return ee;\n}\n\n/**\n * Returns an event emitter scoped specifically for the `fetch` context. This scoping is a remnant from when all the\n * features shared the same group in the event, to isolate events between features. It will likely be revisited.\n * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.\n *     Uses `ee` on the global scope if undefined).\n * @returns {Object} Scoped event emitter with a debug ID of 'fetch'.\n */\nexport function scopedEE(sharedEE) {\n  return (sharedEE || baseEE).get('fetch');\n}","/*\n * Copyright 2020 New Relic Corporation. All rights reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * @file Wraps `pushState` and `replaceState` methods of `window.history` object for instrumentation.\n * This module is used by: session_trace, spa.\n */\nimport { ee as globalEE } from '../event-emitter/contextual-ee';\nimport { createWrapperWithEmitter as wfn } from './wrap-function';\nimport { isBrowserScope } from '../constants/runtime';\nconst wrapped = {};\nconst HISTORY_FNS = ['pushState', 'replaceState'];\n\n/**\n * Wraps the `pushState` and `replaceState` methods of `window.history` and returns a corresponding event emitter\n * scoped to the history object.\n * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.\n * @returns {Object} Scoped event emitter with a debug ID of `history`.\n */\nexport function wrapHistory(sharedEE) {\n  const ee = scopedEE(sharedEE);\n\n  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,\n  // then we increment the count to track # of feats using this at runtime. History API is only\n  // available in browser DOM context.\n  if (!isBrowserScope || wrapped[ee.debugId]++) return ee;\n  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap history\n\n  var wrapFn = wfn(ee);\n  /*\n   * For objects that will be instantiated more than once, we wrap the object's prototype methods. The history object\n   * is instantiated only once, so we can wrap its methods directly--and we must wrap the history methods directly as\n   * long as [Chromium issue 783382](https://bugs.chromium.org/p/chromium/issues/detail?id=783382) remains unresolved.\n   */\n  wrapFn.inPlace(window.history, HISTORY_FNS, '-');\n  return ee;\n}\n\n/**\n * Returns an event emitter scoped specifically for the `history` context. This scoping is a remnant from when all the\n * features shared the same group in the event, to isolate events between features. It will likely be revisited.\n * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.\n *    Uses `ee` on the global scope if undefined).\n * @returns {Object} Scoped event emitter with a debug ID of 'history'.\n */\nexport function scopedEE(sharedEE) {\n  return (sharedEE || globalEE).get('history');\n}","/*\n * Copyright 2020 New Relic Corporation. All rights reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * @file Wraps DOM insertion methods which in turn wrap JSONP functions that show up in the DOM.\n * This module is used by: spa.\n */\n\nimport { eventListenerOpts } from '../event-listener/event-listener-opts';\nimport { ee as baseEE } from '../event-emitter/contextual-ee';\nimport { createWrapperWithEmitter as wfn } from './wrap-function';\nimport { isBrowserScope } from '../constants/runtime';\nconst wrapped = {};\nconst domInsertMethods = ['appendChild', 'insertBefore', 'replaceChild'];\n\n/**\n * Wraps DOM insertion methods to identify script elements containing JSONP callback functions and instruments those\n * functions with custom events in the context of a new event emitter scoped only to JSONP.\n * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.\n * @returns {Object} Scoped event emitter with a debug ID of `jsonp`.\n */\nexport function wrapJsonP(sharedEE) {\n  const ee = scopedEE(sharedEE);\n\n  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,\n  // then we increment the count to track # of feats using this at runtime.  JSONP deals with DOM\n  // tags so browser window env is required.\n  if (!isBrowserScope || wrapped[ee.debugId]) return ee;\n  wrapped[ee.debugId] = true; // otherwise, first feature to wrap JSONP\n\n  var wrapFn = wfn(ee);\n  var CALLBACK_REGEX = /[?&](?:callback|cb)=([^&#]+)/;\n  var PARENT_REGEX = /(.*)\\.([^.]+)/;\n  var VALUE_REGEX = /^(\\w+)(\\.|$)(.*)$/;\n\n  // JSONP works by dynamically inserting <script> elements - wrap DOM methods for\n  // inserting elements to detect insertion of JSONP-specific elements.\n  wrapFn.inPlace(Node.prototype, domInsertMethods, 'dom-');\n  ee.on('dom-start', function (args) {\n    wrapElement(args[0]);\n  });\n\n  // subscribe to events on the JSONP <script> element and wrap the JSONP callback\n  // in order to track start and end of the interaction node\n  function wrapElement(el) {\n    var isScript = el && typeof el.nodeName === 'string' && el.nodeName.toLowerCase() === 'script';\n    if (!isScript) return;\n    var isValidElement = typeof el.addEventListener === 'function';\n    if (!isValidElement) return;\n    var callbackName = extractCallbackName(el.src);\n    if (!callbackName) return;\n    var callback = discoverParent(callbackName);\n    var validCallback = typeof callback.parent[callback.key] === 'function';\n    if (!validCallback) return;\n\n    // At this point we know that the element is a valid JSONP script element.\n    // The following events are emitted during the lifetime of a JSONP call:\n    // * immediately emit `new-jsonp` to notify start of the JSONP work\n    // * the wrapped callback will emit `cb-start` and `cb-end` during the execution\n    //   of the callback, here we can inspect the response\n    // * when the element emits the `load` event (script loaded and executed),\n    //   emit `jsonp-end` to notify end of the JSONP work\n    // * if the element emits the `error` event, in response emit `jsonp-error`\n    //   (and `jsonp-end`). Note that the callback in this case will likely not get\n    //   called.\n\n    var context = {};\n    wrapFn.inPlace(callback.parent, [callback.key], 'cb-', context);\n    el.addEventListener('load', onLoad, eventListenerOpts(false));\n    el.addEventListener('error', onError, eventListenerOpts(false));\n    ee.emit('new-jsonp', [el.src], context);\n    function onLoad() {\n      ee.emit('jsonp-end', [], context);\n      el.removeEventListener('load', onLoad, eventListenerOpts(false));\n      el.removeEventListener('error', onError, eventListenerOpts(false));\n    }\n    function onError() {\n      ee.emit('jsonp-error', [], context);\n      ee.emit('jsonp-end', [], context);\n      el.removeEventListener('load', onLoad, eventListenerOpts(false));\n      el.removeEventListener('error', onError, eventListenerOpts(false));\n    }\n  }\n  function extractCallbackName(src) {\n    var matches = src.match(CALLBACK_REGEX);\n    return matches ? matches[1] : null;\n  }\n\n  /**\n   * Traverse a nested object using a '.'-delimited string wherein each substring piece maps to each subsequent object property layer.\n   * @param {string} longKey\n   * @param {object} obj\n   * @returns The final nested object referred to by initial longKey.\n   */\n  function discoverValue(longKey, obj) {\n    if (!longKey) return obj; // end of object recursion depth when no more key levels\n    const matches = longKey.match(VALUE_REGEX);\n    // if 'longKey' was not undefined, that is it at least had 1 level left, then the regexp would've at least matched 1st group\n    const key = matches[1];\n    const remaining = matches[3];\n    return discoverValue(remaining, obj[key]);\n  }\n  function discoverParent(key) {\n    var matches = key.match(PARENT_REGEX);\n    if (matches && matches.length >= 3) {\n      return {\n        key: matches[2],\n        parent: discoverValue(matches[1], window)\n      };\n    }\n    return {\n      key,\n      parent: window\n    };\n  }\n  return ee;\n}\n\n/**\n * Returns an event emitter scoped specifically for the `jsonp` context. This scoping is a remnant from when all the\n * features shared the same group in the event, to isolate events between features. It will likely be revisited.\n * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.\n *     Uses `ee` on the global scope if undefined).\n * @returns {Object} Scoped event emitter with a debug ID of 'jsonp'.\n */\nexport function scopedEE(sharedEE) {\n  return (sharedEE || baseEE).get('jsonp');\n}","/*\n * Copyright 2020 New Relic Corporation. All rights reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * @file Wraps the window's DOM mutation observer for instrumentation.\n * This module is used by: spa.\n */\n\nimport { ee as baseEE } from '../event-emitter/contextual-ee';\nimport { createWrapperWithEmitter as wfn } from './wrap-function';\nimport { globalScope, isBrowserScope } from '../constants/runtime';\nconst wrapped = {};\n\n/**\n * In web environments only, wraps the `window.MutationObserver` function to emit events on start, end, and error, in\n * the context of a new event emitter scoped only to mutations.\n * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.\n * @returns {Object} Scoped event emitter with a debug ID of `mutation`.\n */\nexport function wrapMutation(sharedEE) {\n  const ee = scopedEE(sharedEE);\n\n  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,\n  // then we increment the count to track # of feats using this at runtime. Mutations API is only\n  // available in browser DOM context.\n  if (!isBrowserScope || wrapped[ee.debugId]) return ee;\n  wrapped[ee.debugId] = true; // otherwise, first feature to wrap mutations\n\n  var wrapFn = wfn(ee);\n  var OriginalObserver = globalScope.MutationObserver;\n  if (OriginalObserver) {\n    window.MutationObserver = function WrappedMutationObserver(cb) {\n      if (this instanceof OriginalObserver) {\n        return new OriginalObserver(wrapFn(cb, 'fn-'));\n      } else {\n        return OriginalObserver.apply(this, arguments);\n      }\n    };\n    MutationObserver.prototype = OriginalObserver.prototype;\n  }\n  return ee;\n}\n\n/**\n * Returns an event emitter scoped specifically for the `mutation` context. This scoping is a remnant from when all the\n * features shared the same group in the event, to isolate events between features. It will likely be revisited.\n * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.\n *     Uses `ee` on the global scope if undefined).\n * @returns {Object} Scoped event emitter with a debug ID of 'mutation'.\n */\nexport function scopedEE(sharedEE) {\n  return (sharedEE || baseEE).get('mutation');\n}","/*\n * Copyright 2020 New Relic Corporation. All rights reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * @file Wraps the native Promise object for instrumentation.\n * This module is used by: spa.\n */\n\nimport { createWrapperWithEmitter as wrapFn, flag } from './wrap-function';\nimport { ee as baseEE } from '../event-emitter/contextual-ee';\nimport { globalScope } from '../constants/runtime';\nconst wrapped = {};\n\n/**\n * Wraps the native Promise object so that it will emit events for start, end and error in the context of a new event\n * emitter scoped only to promise methods. Also instruments various methods, such as `all`, `race`, `resolve`,\n * `reject`, `then`, and `catch`.\n * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.\n * @returns {Object} Scoped event emitter with a debug ID of `promise`.\n */\nexport function wrapPromise(sharedEE) {\n  const promiseEE = scopedEE(sharedEE);\n\n  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,\n  // then we increment the count to track # of feats using this at runtime.\n  if (wrapped[promiseEE.debugId]) return promiseEE;\n  wrapped[promiseEE.debugId] = true; // otherwise, first feature to wrap promise\n\n  var getContext = promiseEE.context;\n  var promiseWrapper = wrapFn(promiseEE);\n  var prevPromiseObj = globalScope.Promise;\n  if (prevPromiseObj) {\n    // ensure there's a Promise API (native or otherwise) to even wrap\n    wrap();\n  }\n  function wrap() {\n    globalScope.Promise = WrappedPromise;\n\n    // Renamed from \"WrappedPromise\" back to \"Promise\" & toString() so that we appear \"native\" to TP libraries...\n    Object.defineProperty(WrappedPromise, 'name', {\n      value: 'Promise'\n    });\n    WrappedPromise.toString = function () {\n      return prevPromiseObj.toString();\n    };\n\n    /**\n     * This constitutes the global used when calling \"Promise.staticMethod\" or chaining off a \"new Promise()\" object.\n     * @param {Function} executor - to be executed by the original Promise constructor\n     * @returns A new WrappedPromise object prototyped off the original.\n     */\n    function WrappedPromise(executor) {\n      var ctx = promiseEE.context();\n      var wrappedExecutor = promiseWrapper(executor, 'executor-', ctx, null, false);\n      const newCustomPromiseInst = Reflect.construct(prevPromiseObj, [wrappedExecutor], WrappedPromise); // new Promises will use WrappedPromise.prototype as theirs prototype\n\n      promiseEE.context(newCustomPromiseInst).getCtx = function () {\n        return ctx;\n      };\n      return newCustomPromiseInst;\n    }\n\n    // Make WrappedPromise inherit statics from the orig Promise.\n    Object.setPrototypeOf(WrappedPromise, prevPromiseObj);\n    ['all', 'race'].forEach(function (method) {\n      const prevStaticFn = prevPromiseObj[method];\n      WrappedPromise[method] = function (subPromises) {\n        // use our own wrapped version of \"Promise.all\" and \".race\" static fns\n        let finalized = false;\n        [...(subPromises || [])].forEach(sub => {\n          this.resolve(sub).then(setNrId(method === 'all'), setNrId(false));\n        });\n        const origFnCallWithThis = prevStaticFn.apply(this, arguments);\n        return origFnCallWithThis;\n        function setNrId(overwrite) {\n          return function () {\n            promiseEE.emit('propagate', [null, !finalized], origFnCallWithThis, false, false);\n            finalized = finalized || !overwrite;\n          };\n        }\n      };\n    });\n    ['resolve', 'reject'].forEach(function (method) {\n      const prevStaticFn = prevPromiseObj[method];\n      WrappedPromise[method] = function (val) {\n        // and the same for \".resolve\" and \".reject\"\n        const origFnCallWithThis = prevStaticFn.apply(this, arguments);\n        if (val !== origFnCallWithThis) {\n          promiseEE.emit('propagate', [val, true], origFnCallWithThis, false, false);\n        }\n        return origFnCallWithThis;\n      };\n    });\n\n    /*\n     * Ideally, we create a new WrappedPromise.prototype chained off the original Promise's so that we don't alter it.\n     * However, there's no way to make the (native) promise returned from async functions use our WrappedPromise,\n     * so we have to modify the original prototype. This ensures that promises returned from async functions execute\n     * the same instance methods as promises created with \"new Promise()\", and also that instanceof async() is\n     * the global Promise (see GH issue #409). This also affects the promise returned from fetch().\n     */\n    WrappedPromise.prototype = prevPromiseObj.prototype;\n\n    // Note that this wrapping affects the same originals.PR (prototype) object.\n    const prevPromiseOrigThen = prevPromiseObj.prototype.then;\n    prevPromiseObj.prototype.then = function wrappedThen() {\n      var originalThis = this;\n      var ctx = getContext(originalThis);\n      ctx.promise = originalThis;\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n      args[0] = promiseWrapper(args[0], 'cb-', ctx, null, false);\n      args[1] = promiseWrapper(args[1], 'cb-', ctx, null, false);\n      const origFnCallWithThis = prevPromiseOrigThen.apply(this, args);\n      ctx.nextPromise = origFnCallWithThis;\n      promiseEE.emit('propagate', [originalThis, true], origFnCallWithThis, false, false);\n      return origFnCallWithThis;\n    };\n    prevPromiseObj.prototype.then[flag] = prevPromiseOrigThen;\n    promiseEE.on('executor-start', function (args) {\n      args[0] = promiseWrapper(args[0], 'resolve-', this, null, false);\n      args[1] = promiseWrapper(args[1], 'resolve-', this, null, false);\n    });\n    promiseEE.on('executor-err', function (args, originalThis, err) {\n      args[1](err);\n    });\n    promiseEE.on('cb-end', function (args, originalThis, result) {\n      promiseEE.emit('propagate', [result, true], this.nextPromise, false, false);\n    });\n    promiseEE.on('propagate', function (val, overwrite, trigger) {\n      if (!this.getCtx || overwrite) {\n        this.getCtx = function () {\n          // eslint-disable-next-line\n          if (val instanceof Promise) {\n            var store = promiseEE.context(val);\n          }\n          return store && store.getCtx ? store.getCtx() : this;\n        };\n      }\n    });\n  }\n  return promiseEE;\n}\n\n/**\n * Returns an event emitter scoped specifically for the `promise` context. This scoping is a remnant from when all the\n * features shared the same group in the event, to isolate events between features. It will likely be revisited.\n * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.\n *     Uses `ee` on the global scope if undefined).\n * @returns {Object} Scoped event emitter with a debug ID of 'promise'.\n */\nexport function scopedEE(sharedEE) {\n  return (sharedEE || baseEE).get('promise');\n}","/*\n * Copyright 2020 New Relic Corporation. All rights reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * @file Wraps native timeout and interval methods for instrumentation.\n * This module is used by: jserrors, spa.\n */\n\nimport { ee as baseEE } from '../event-emitter/contextual-ee';\nimport { createWrapperWithEmitter as wfn } from './wrap-function';\nimport { globalScope } from '../constants/runtime';\nconst wrapped = {};\nconst SET_TIMEOUT = 'setTimeout';\nconst SET_INTERVAL = 'setInterval';\nconst CLEAR_TIMEOUT = 'clearTimeout';\nconst START = '-start';\nconst DASH = '-';\nconst TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'clearImmediate'];\n\n/**\n * Wraps the global `setTimeout`, `setImmediate`, `setInterval`, `clearTimeout`, and `clearImmediate` functions to emit\n * events on start, end, and error, in the context of a new event emitter scoped only to timer functions. Also wraps\n * the callbacks of `setTimeout` and `setInterval`.\n * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.\n * @returns {Object} Scoped event emitter with a debug ID of `timer`.\n */\n// eslint-disable-next-line\nexport function wrapTimer(sharedEE) {\n  const ee = scopedEE(sharedEE);\n\n  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,\n  // then we increment the count to track # of feats using this at runtime.\n  if (wrapped[ee.debugId]++) return ee;\n  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap timer\n\n  var wrapFn = wfn(ee);\n  wrapFn.inPlace(globalScope, TIMER_FNS.slice(0, 2), SET_TIMEOUT + DASH);\n  wrapFn.inPlace(globalScope, TIMER_FNS.slice(2, 3), SET_INTERVAL + DASH);\n  wrapFn.inPlace(globalScope, TIMER_FNS.slice(3), CLEAR_TIMEOUT + DASH);\n  ee.on(SET_INTERVAL + START, interval);\n  ee.on(SET_TIMEOUT + START, timer);\n  function interval(args, obj, type) {\n    args[0] = wrapFn(args[0], 'fn-', null, type);\n  }\n  function timer(args, obj, type) {\n    this.method = type;\n    this.timerDuration = isNaN(args[1]) ? 0 : +args[1];\n    args[0] = wrapFn(args[0], 'fn-', this, type);\n  }\n  return ee;\n}\n\n/**\n * Returns an event emitter scoped specifically for the `timer` context. This scoping is a remnant from when all the\n * features shared the same group in the event, to isolate events between features. It will likely be revisited.\n * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.\n *     Uses `ee` on the global scope if undefined).\n * @returns {Object} Scoped event emitter with a debug ID of 'timer'.\n */\nexport function scopedEE(sharedEE) {\n  return (sharedEE || baseEE).get('timer');\n}","/*\n * Copyright 2020 New Relic Corporation. All rights reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * @file Wraps AJAX (XHR) related methods for instrumentation.\n * This module is used by: ajax, jserrors, spa.\n */\n\nimport { wrapEvents } from './wrap-events';\nimport { ee as contextualEE } from '../event-emitter/contextual-ee';\nimport { eventListenerOpts } from '../event-listener/event-listener-opts';\nimport { createWrapperWithEmitter as wfn } from './wrap-function';\nimport { globalScope } from '../constants/runtime';\nimport { warn } from '../util/console';\nconst wrapped = {};\nconst XHR_PROPS = ['open', 'send']; // these are the specific funcs being wrapped on all XMLHttpRequests(.prototype)\n\n/**\n * Wraps the native XMLHttpRequest (XHR) object to emit custom events to its readystatechange event and an assortment\n * of handlers. Adds instrumentation in context of a new event emitter scoped only to XHR.\n * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.\n * @returns {Object} Scoped event emitter with a debug ID of `xhr`.\n */\n// eslint-disable-next-line\nexport function wrapXhr(sharedEE) {\n  var baseEE = sharedEE || contextualEE;\n  const ee = scopedEE(baseEE);\n\n  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,\n  // then we increment the count to track # of feats using this at runtime.\n  if (wrapped[ee.debugId]++) return ee;\n  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap XHR\n\n  wrapEvents(baseEE); // wrap-events patches XMLHttpRequest.prototype.addEventListener for us\n  var wrapFn = wfn(ee);\n  var OrigXHR = globalScope.XMLHttpRequest;\n  var MutationObserver = globalScope.MutationObserver;\n  var Promise = globalScope.Promise;\n  var setImmediate = globalScope.setInterval;\n  var READY_STATE_CHANGE = 'readystatechange';\n  var handlers = ['onload', 'onerror', 'onabort', 'onloadstart', 'onloadend', 'onprogress', 'ontimeout'];\n  var pendingXhrs = [];\n  var XHR = globalScope.XMLHttpRequest = newXHR;\n  function newXHR(opts) {\n    const xhr = new OrigXHR(opts);\n    const context = ee.context(xhr);\n    try {\n      ee.emit('new-xhr', [xhr], context);\n      xhr.addEventListener(READY_STATE_CHANGE, wrapXHR(context), eventListenerOpts(false));\n    } catch (e) {\n      warn('An error occurred while intercepting XHR', e);\n      try {\n        ee.emit('internal-error', [e]);\n      } catch (err) {\n        // do nothing\n      }\n    }\n    return xhr;\n  }\n  copy(OrigXHR, XHR);\n  XHR.prototype = OrigXHR.prototype;\n  wrapFn.inPlace(XHR.prototype, XHR_PROPS, '-xhr-', getObject);\n  ee.on('send-xhr-start', function (args, xhr) {\n    wrapOnreadystatechange(args, xhr);\n    enqueuePendingXhr(xhr);\n  });\n  ee.on('open-xhr-start', wrapOnreadystatechange);\n  function wrapOnreadystatechange(args, xhr) {\n    wrapFn.inPlace(xhr, ['onreadystatechange'], 'fn-', getObject);\n  }\n  function wrapXHR(ctx) {\n    return function () {\n      var xhr = this;\n      if (xhr.readyState > 3 && !ctx.resolved) {\n        ctx.resolved = true;\n        ee.emit('xhr-resolved', [], xhr);\n      }\n      wrapFn.inPlace(xhr, handlers, 'fn-', getObject);\n    };\n  }\n\n  // Wrapping the onreadystatechange property of XHRs takes some special tricks.\n  //\n  // The issue is that the onreadystatechange property may be assigned *after*\n  // send() is called against an XHR. This is of particular importance because\n  // jQuery uses a single onreadystatechange handler to implement all of the XHR\n  // callbacks thtat it provides, and it assigns that property after calling send.\n  //\n  // There are several 'obvious' approaches to wrapping the onreadystatechange\n  // when it's assigned after send:\n  //\n  // 1. Try to wrap the onreadystatechange handler from a readystatechange\n  //    addEventListener callback (the addEventListener callback will fire before\n  //    the onreadystatechange callback).\n  //\n  //      Caveat: this doesn't work in Chrome or Safari, and in fact will cause\n  //      the onreadystatechange handler to not be invoked at all during the\n  //      firing cycle in which it is wrapped, which may break applications :(\n  //\n  // 2. Use Object.defineProperty to create a setter for the onreadystatechange\n  //    property, and wrap from that setter.\n  //\n  //      Caveat: onreadystatechange is not a configurable property in Safari or\n  //      older versions of the Android browser.\n  //\n  // 3. Schedule wrapping of the onreadystatechange property using a setTimeout\n  //    call issued just before the call to send.\n  //\n  //      Caveat: sometimes, the onreadystatechange handler fires before the\n  //      setTimeout, meaning the wrapping happens too late.\n  //\n  // The setTimeout approach is closest to what we use here: we want to schedule\n  // the wrapping of the onreadystatechange property when send is called, but\n  // ensure that our wrapping happens before onreadystatechange has a chance to\n  // fire.\n  //\n  // We achieve this using a hybrid approach:\n  //\n  // * In browsers that support MutationObserver, we use that to schedule wrapping\n  //   of onreadystatechange.\n  //\n  // * We have discovered that MutationObserver in IE causes a memory leak, so we\n  //   now will prefer setImmediate for IE, and use a resolved promise to schedule\n  //   the wrapping in Edge (and other browsers that support promises)\n  //\n  // * In older browsers that don't support MutationObserver, we rely on the fact\n  //   that the call to send is probably happening within a callback that we've\n  //   already wrapped, and use our existing fn-end event callback to wrap the\n  //   onreadystatechange at the end of the current callback.\n  //\n\n  if (MutationObserver) {\n    var resolved = Promise && Promise.resolve();\n    if (!setImmediate && !Promise) {\n      var toggle = 1;\n      var dummyNode = document.createTextNode(toggle);\n      new MutationObserver(drainPendingXhrs).observe(dummyNode, {\n        characterData: true\n      });\n    }\n  } else {\n    // this below case applies to web workers too\n    baseEE.on('fn-end', function (args) {\n      // We don't want to try to wrap onreadystatechange from within a\n      // readystatechange callback.\n      if (args[0] && args[0].type === READY_STATE_CHANGE) return;\n      drainPendingXhrs();\n    });\n  }\n  function enqueuePendingXhr(xhr) {\n    pendingXhrs.push(xhr);\n    if (MutationObserver) {\n      if (resolved) {\n        resolved.then(drainPendingXhrs);\n      } else if (setImmediate) {\n        setImmediate(drainPendingXhrs);\n      } else {\n        toggle = -toggle;\n        dummyNode.data = toggle;\n      }\n    }\n  }\n  function drainPendingXhrs() {\n    for (var i = 0; i < pendingXhrs.length; i++) {\n      wrapOnreadystatechange([], pendingXhrs[i]);\n    }\n    if (pendingXhrs.length) pendingXhrs = [];\n  }\n\n  // Use the object these methods are on as their\n  // context store for the event emitter\n  function getObject(args, obj) {\n    return obj;\n  }\n  function copy(from, to) {\n    for (var i in from) {\n      to[i] = from[i];\n    }\n    return to;\n  }\n  return ee;\n}\n\n/**\n * Returns an event emitter scoped specifically for the `xhr` context. This scoping is a remnant from when all the\n * features shared the same group in the event, to isolate events between features. It will likely be revisited.\n * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.\n *     Uses `ee` on the global scope if undefined).\n * @returns {Object} Scoped event emitter with a debug ID of 'xhr'.\n */\nexport function scopedEE(sharedEE) {\n  return (sharedEE || contextualEE).get('xhr');\n}"],"mappings":"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","names":["wrapped","XHR","globalScope","ADD_EVENT_LISTENER","REMOVE_EVENT_LISTENER","flag","contextId","wrapEvents","sharedEE","ee","scopedEE","wrapFn","createWrapperWithEmitter","isBrowserScope","findEventListenerProtoAndCb","wrapNode","args","target","originalListener","getOrSet","listener","wrapHandleEvent","node","uniqueListener","obj","object","cb","step","_len","rest","_key","globalInstance","prefix","bodyPrefix","bodyMethods","Req","globalScope","Res","proto","wrapped","wrapFetch","sharedEE","ee","scopedEE","method","wrapPromiseMethod","err","res","ctx","size","target","name","fn","args","dtPayload","contextId","origPromiseFromFetch","val","globalInstance","wrapped","HISTORY_FNS","wrapHistory","sharedEE","ee","scopedEE","isBrowserScope","wrapFn","createWrapperWithEmitter","globalInstance","wrapped","domInsertMethods","wrapJsonP","sharedEE","ee","scopedEE","isBrowserScope","wrapFn","createWrapperWithEmitter","CALLBACK_REGEX","PARENT_REGEX","VALUE_REGEX","args","wrapElement","el","isScript","isValidElement","callbackName","extractCallbackName","callback","discoverParent","validCallback","context","onLoad","eventListenerOpts","onError","src","matches","discoverValue","longKey","obj","key","remaining","globalInstance","wrapped","wrapMutation","sharedEE","ee","scopedEE","isBrowserScope","wrapFn","createWrapperWithEmitter","OriginalObserver","globalScope","cb","globalInstance","wrapped","wrapPromise","sharedEE","promiseEE","scopedEE","getContext","promiseWrapper","createWrapperWithEmitter","prevPromiseObj","globalScope","wrap","WrappedPromise","executor","ctx","wrappedExecutor","newCustomPromiseInst","method","prevStaticFn","subPromises","finalized","sub","setNrId","origFnCallWithThis","overwrite","val","prevPromiseOrigThen","originalThis","_len","args","_key","flag","err","result","trigger","store","globalInstance","wrapped","SET_TIMEOUT","SET_INTERVAL","CLEAR_TIMEOUT","START","DASH","TIMER_FNS","wrapTimer","sharedEE","ee","scopedEE","wrapFn","createWrapperWithEmitter","globalScope","interval","timer","args","obj","type","globalInstance","wrapped","XHR_PROPS","wrapXhr","sharedEE","baseEE","globalInstance","ee","scopedEE","wrapEvents","wrapFn","createWrapperWithEmitter","OrigXHR","globalScope","MutationObserver","Promise","setImmediate","READY_STATE_CHANGE","handlers","pendingXhrs","XHR","newXHR","opts","xhr","context","wrapXHR","eventListenerOpts","e","warn","copy","getObject","args","wrapOnreadystatechange","enqueuePendingXhr","ctx","resolved","toggle","dummyNode","drainPendingXhrs","i","obj","from","to"],"x_google_ignoreList":[0,1,2,3,4,5,6,7]}