@newrelic/browser-agent 1.239.1 → 1.241.0

package/dist/esm/common/vitals/first-contentful-paint.js

@@ -0,0 +1,41 @@
+import { onFCP } from 'web-vitals';
+// eslint-disable-next-line camelcase
+import { iOSBelow16, initiallyHidden, isBrowserScope } from '../constants/runtime';
+import { VITAL_NAMES } from './constants';
+import { VitalMetric } from './vital-metric';
+export const firstContentfulPaint = new VitalMetric(VITAL_NAMES.FIRST_CONTENTFUL_PAINT);
+
+/* First Contentful Paint - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
+if (isBrowserScope) {
+  // eslint-disable-next-line camelcase
+  if (iOSBelow16) {
+    try {
+      if (!initiallyHidden) {
+        // see ios-version.js for detail on this following bug case; tldr: buffered flag doesn't work but getEntriesByType does
+        const paintEntries = performance.getEntriesByType('paint');
+        paintEntries.forEach(entry => {
+          if (entry.name === 'first-contentful-paint') {
+            firstContentfulPaint.update({
+              value: Math.floor(entry.startTime),
+              entries: paintEntries
+            });
+          }
+        });
+      }
+    } catch (e) {
+      // ignore
+    }
+  } else {
+    onFCP(_ref => {
+      let {
+        value,
+        entries
+      } = _ref;
+      if (initiallyHidden || firstContentfulPaint.isValid) return;
+      firstContentfulPaint.update({
+        value,
+        entries
+      });
+    });
+  }
+}

package/dist/esm/common/vitals/first-input-delay.js

@@ -0,0 +1,25 @@
+import { onFID } from 'web-vitals';
+import { VitalMetric } from './vital-metric';
+import { VITAL_NAMES } from './constants';
+import { initiallyHidden, isBrowserScope } from '../constants/runtime';
+export const firstInputDelay = new VitalMetric(VITAL_NAMES.FIRST_INPUT_DELAY);
+if (isBrowserScope) {
+  onFID(_ref => {
+    let {
+      value,
+      entries
+    } = _ref;
+    if (initiallyHidden || firstInputDelay.isValid || entries.length === 0) return;
+
+    // CWV will only report one (THE) first-input entry to us; fid isn't reported if there are no user interactions occurs before the *first* page hiding.
+    firstInputDelay.update({
+      value: entries[0].startTime,
+      entries,
+      attrs: {
+        type: entries[0].name,
+        fid: Math.round(value)
+      },
+      shouldAddConnectionAttributes: true
+    });
+  });
+}

package/dist/{cjs/features/page_view_timing → esm/common/vitals}/first-paint.js

@@ -1,33 +1,24 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.onFirstPaint = void 0;
-/**
- * Calls the `onReport` function when the 'first-paint' PerformancePaintTiming entry is observed.
- * The argument supplied is an object similar to the Metric type used by web-vitals library.
- *
- * @param {Function} onReport - callback that accepts a `metric` object as the single parameter
- */
-const onFirstPaint = onReport => {
+import { initiallyHidden, isBrowserScope } from '../constants/runtime';
+import { VITAL_NAMES } from './constants';
+import { VitalMetric } from './vital-metric';
+export const firstPaint = new VitalMetric(VITAL_NAMES.FIRST_PAINT);
+if (isBrowserScope) {
   const handleEntries = entries => {
     entries.forEach(entry => {
-      if (entry.name === 'first-paint') {
+      if (entry.name === 'first-paint' && !firstPaint.isValid) {
         observer.disconnect();
 
         /* Initial hidden state and pre-rendering not yet considered for first paint. See web-vitals onFCP for example. */
-        const metric = {
-          name: 'FP',
-          value: entry.startTime
-        };
-        onReport(metric);
+        firstPaint.update({
+          value: entry.startTime,
+          entries
+        });
       }
     });
   };
   let observer;
   try {
-    if (PerformanceObserver.supportedEntryTypes.includes('paint')) {
+    if (PerformanceObserver.supportedEntryTypes.includes('paint') && !initiallyHidden) {
       observer = new PerformanceObserver(list => {
         // Delay by a microtask to workaround a bug in Safari where the
         // callback is invoked immediately, rather than in a separate task.
@@ -44,7 +35,4 @@ const onFirstPaint = onReport => {
   } catch (e) {
     // Do nothing.
   }
-
-  /* BFCache restore not yet considered for first paint. See web-vitals onFCP for example. */
-};
-exports.onFirstPaint = onFirstPaint;
+}

package/dist/esm/common/vitals/interaction-to-next-paint.js

@@ -0,0 +1,22 @@
+import { onINP } from 'web-vitals';
+import { VitalMetric } from './vital-metric';
+import { VITAL_NAMES } from './constants';
+import { isBrowserScope } from '../constants/runtime';
+export const interactionToNextPaint = new VitalMetric(VITAL_NAMES.INTERACTION_TO_NEXT_PAINT);
+if (isBrowserScope) {
+  /* Interaction-to-Next-Paint */
+  onINP(_ref => {
+    let {
+      value,
+      entries,
+      id
+    } = _ref;
+    interactionToNextPaint.update({
+      value,
+      entries,
+      attrs: {
+        metricId: id
+      }
+    });
+  });
+}

package/dist/esm/common/vitals/largest-contentful-paint.js

@@ -0,0 +1,34 @@
+import { onLCP } from 'web-vitals';
+import { VitalMetric } from './vital-metric';
+import { VITAL_NAMES } from './constants';
+import { initiallyHidden, isBrowserScope } from '../constants/runtime';
+import { cleanURL } from '../url/clean-url';
+export const largestContentfulPaint = new VitalMetric(VITAL_NAMES.LARGEST_CONTENTFUL_PAINT);
+if (isBrowserScope) {
+  onLCP(_ref => {
+    let {
+      value,
+      entries
+    } = _ref;
+    /* Largest Contentful Paint - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
+    if (initiallyHidden || largestContentfulPaint.isValid) return;
+    const lcpEntry = entries[entries.length - 1]; // this looks weird if we only expect one, but this is how cwv-attribution gets it so to be sure...
+    largestContentfulPaint.update({
+      value,
+      entries,
+      ...(entries.length > 0 && {
+        attrs: {
+          size: lcpEntry.size,
+          eid: lcpEntry.id,
+          ...(!!lcpEntry.url && {
+            elUrl: cleanURL(lcpEntry.url)
+          }),
+          ...(!!lcpEntry.element?.tagName && {
+            elTag: lcpEntry.element.tagName
+          })
+        }
+      }),
+      shouldAddConnectionAttributes: true
+    });
+  });
+}

package/dist/esm/common/vitals/long-task.js

@@ -0,0 +1,57 @@
+import { isBrowserScope } from '../constants/runtime';
+import { subscribeToEOL } from '../unload/eol';
+import { VITAL_NAMES } from './constants';
+import { VitalMetric } from './vital-metric';
+export const longTask = new VitalMetric(VITAL_NAMES.LONG_TASK);
+if (isBrowserScope) {
+  const handleEntries = entries => {
+    entries.forEach(entry => {
+      longTask.update({
+        value: entry.duration,
+        entries: [entry],
+        attrs: {
+          ltFrame: entry.name,
+          // MDN: the browsing context or frame that can be attributed to the long task
+          ltStart: entry.startTime,
+          // MDN: a double representing the time (millisec) when the task started
+          ltCtr: entry.attribution[0].containerType,
+          // MDN: type of frame container: 'iframe', 'embed', or 'object' ... but this can also be 'window',
+          ...(entry.attribution[0].containerType !== 'window' && {
+            ltCtrSrc: entry.attribution[0].containerSrc,
+            // MDN: container's 'src' attribute
+            ltCtrId: entry.attribution[0].containerId,
+            // MDN: container's 'id' attribute
+            ltCtrName: entry.attribution[0].containerName // MDN: container's 'name' attribute
+          })
+        }
+      });
+    });
+  };
+
+  let observer;
+  try {
+    if (PerformanceObserver.supportedEntryTypes.includes('longtask')) {
+      observer = new PerformanceObserver(list => {
+        // Delay by a microtask to workaround a bug in Safari where the
+        // callback is invoked immediately, rather than in a separate task.
+        // See: https://github.com/GoogleChrome/web-vitals/issues/277
+        Promise.resolve().then(() => {
+          handleEntries(list.getEntries());
+        });
+      });
+      observer.observe({
+        type: 'longtask',
+        buffered: true
+      });
+    }
+  } catch (e) {
+    // Do nothing.
+  }
+  if (observer) {
+    subscribeToEOL(() => {
+      handleEntries(observer.takeRecords());
+    }, true); // this bool is a temp arg under staged BFCache work that runs the func under the new page session logic -- tb removed w/ the feature flag later
+
+    /* No work needed on BFCache restore for long task. */
+  }
+}

package/dist/esm/common/vitals/time-to-first-byte.js

@@ -0,0 +1,29 @@
+import { globalScope, isBrowserScope, isiOS, offset } from '../constants/runtime';
+import { VITAL_NAMES } from './constants';
+import { VitalMetric } from './vital-metric';
+import { onTTFB } from 'web-vitals';
+export const timeToFirstByte = new VitalMetric(VITAL_NAMES.TIME_TO_FIRST_BYTE);
+if (isBrowserScope && typeof PerformanceNavigationTiming !== 'undefined' && !isiOS) {
+  onTTFB(_ref => {
+    let {
+      value,
+      entries
+    } = _ref;
+    if (!timeToFirstByte.isValid) timeToFirstByte.update({
+      value,
+      entries
+    });
+  });
+} else {
+  if (!timeToFirstByte.isValid) {
+    const entry = {};
+    // convert real timestamps to relative timestamps to match web-vitals behavior
+    for (let key in globalScope?.performance?.timing || {}) entry[key] = Math.max(globalScope?.performance?.timing[key] - offset, 0);
+
+    // ttfb is equiv to document's responseStart property in timing API --> https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming/responseStart
+    timeToFirstByte.update({
+      value: entry.responseStart,
+      entries: [entry]
+    });
+  }
+}

package/dist/esm/common/vitals/vital-metric.js

@@ -0,0 +1,64 @@
+export class VitalMetric {
+  #subscribers = new Set();
+  history = [];
+  constructor(name, roundingMethod) {
+    this.name = name;
+    this.attrs = {};
+    this.roundingMethod = typeof roundingMethod === 'function' ? roundingMethod : Math.floor;
+  }
+  update(_ref) {
+    let {
+      value,
+      entries = [],
+      attrs = {},
+      shouldAddConnectionAttributes = false
+    } = _ref;
+    if (value < 0) return;
+    const state = {
+      value: this.roundingMethod(value),
+      name: this.name,
+      entries,
+      attrs
+    };
+    if (shouldAddConnectionAttributes) addConnectionAttributes(state.attrs);
+    this.history.push(state);
+    this.#subscribers.forEach(cb => {
+      try {
+        cb(this.current);
+      } catch (e) {
+        // ignore errors
+      }
+    });
+  }
+  get current() {
+    return this.history[this.history.length - 1] || {
+      value: undefined,
+      name: this.name,
+      entries: [],
+      attrs: {}
+    };
+  }
+  get isValid() {
+    return this.current.value >= 0;
+  }
+  subscribe(callback) {
+    let buffered = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    if (typeof callback !== 'function') return;
+    this.#subscribers.add(callback);
+    // emit full history on subscription ("buffered" behavior)
+    if (this.isValid && !!buffered) this.history.forEach(state => {
+      callback(state);
+    });
+    return () => {
+      this.#subscribers.delete(callback);
+    };
+  }
+}
+function addConnectionAttributes(obj) {
+  var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection; // to date, both window & worker shares the same support for connection
+  if (!connection) return;
+  if (connection.type) obj['net-type'] = connection.type;
+  if (connection.effectiveType) obj['net-etype'] = connection.effectiveType;
+  if (connection.rtt) obj['net-rtt'] = connection.rtt;
+  if (connection.downlink) obj['net-dlink'] = connection.downlink;
+}

package/dist/esm/features/ajax/aggregate/index.js

@@ -64,6 +64,8 @@ export class Aggregate extends AggregateBase {
       scheduler.startTimer(harvestTimeSeconds);
     });
     this.drain();
+    const beacon = getInfo(agentIdentifier).errorBeacon;
+    const proxyBeacon = agentInit.proxy.beacon;
     function storeXhr(params, metrics, startTime, endTime, type) {
       metrics.time = startTime;
 
@@ -80,7 +82,8 @@ export class Aggregate extends AggregateBase {
       aggregator.store('xhr', hash, params, metrics);
       if (!allAjaxIsEnabled) return;
       if (!shouldCollectEvent(params)) {
-        if (params.hostname === getInfo(agentIdentifier).errorBeacon) {
+        if (params.hostname === beacon || proxyBeacon && params.hostname === proxyBeacon) {
+          // This doesn't make a distinction if the same-domain request is going to a different port or path...
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
         } else {
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);

package/dist/esm/features/metrics/aggregate/index.js

@@ -1,4 +1,4 @@
-import { getRuntime } from '../../../common/config/config';
+import { getRuntime, getConfiguration } from '../../../common/config/config';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL } from '../constants';
@@ -27,13 +27,16 @@ export class Aggregate extends AggregateBase {
     this.singleChecks(); // checks that are run only one time, at script load
     this.eachSessionChecks(); // the start of every time user engages with page
 
-    // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
-    scheduler = new HarvestScheduler('jserrors', {
-      onUnload: () => this.unload()
-    }, this);
-    scheduler.harvest.on('jserrors', () => ({
-      body: this.aggregator.take(['cm', 'sm'])
-    }));
+    this.ee.on("drain-".concat(this.featureName), () => {
+      // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
+      scheduler = new HarvestScheduler('jserrors', {
+        onUnload: () => this.unload()
+      }, this);
+      scheduler.harvest.on('jserrors', () => ({
+        body: this.aggregator.take(['cm', 'sm'])
+      }));
+    }); // this is needed to ensure EoL is "on" and sent
+
     this.drain();
   }
   storeSupportabilityMetrics(name, value) {
@@ -87,6 +90,13 @@ export class Aggregate extends AggregateBase {
     const rules = getRules(this.agentIdentifier);
     if (rules.length > 0) this.storeSupportabilityMetrics('Generic/Obfuscate/Detected');
     if (rules.length > 0 && !validateRules(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid');
+
+    // Check if proxy for either chunks or beacon is being used
+    const {
+      proxy
+    } = getConfiguration(this.agentIdentifier);
+    if (proxy.assets) this.storeSupportabilityMetrics('Config/AssetsUrl/Changed');
+    if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed');
   }
   eachSessionChecks() {
     if (!isBrowserScope) return;

package/dist/esm/features/page_view_event/aggregate/index.js

@@ -1,53 +1,42 @@
-import { handle } from '../../../common/event-emitter/handle';
-import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { isiOS, globalScope, isBrowserScope } from '../../../common/constants/runtime';
-import { onTTFB } from 'web-vitals';
+import { globalScope, isBrowserScope } from '../../../common/constants/runtime';
 import { addPT, addPN } from '../../../common/timing/nav-timing';
 import { stringify } from '../../../common/util/stringify';
-import { paintMetrics } from '../../../common/metrics/paint-metrics';
-import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
+import { getInfo, getRuntime } from '../../../common/config/config';
 import { Harvest } from '../../../common/harvest/harvest';
 import * as CONSTANTS from '../constants';
 import { getActivatedFeaturesFlags } from './initialized-features';
 import { activateFeatures } from '../../../common/util/feature-flags';
 import { warn } from '../../../common/util/console';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint';
+import { firstPaint } from '../../../common/vitals/first-paint';
+import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte';
 export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME);
-    if (typeof PerformanceNavigationTiming !== 'undefined' && !isiOS) {
-      this.alreadySent = false; // we don't support timings on BFCache restores
-      const agentRuntime = getRuntime(agentIdentifier); // we'll store timing values on the runtime obj to be read by the aggregate module
+    this.timeToFirstByte = 0;
+    this.firstByteToWindowLoad = 0; // our "frontend" duration
+    this.firstByteToDomContent = 0; // our "dom processing" duration
 
-      /* Time To First Byte
-        This listener must record these values *before* PVE's aggregate sends RUM. */
-      onTTFB(_ref => {
+    if (isBrowserScope) {
+      timeToFirstByte.subscribe(_ref => {
         let {
           value,
           entries
         } = _ref;
-        if (this.alreadySent) return;
-        this.alreadySent = true;
-        agentRuntime[CONSTANTS.TTFB] = Math.round(value); // this is our "backend" duration; web-vitals will ensure it's lower bounded at 0
-
-        // Similar to what vitals does for ttfb, we have to factor in activation-start when calculating relative timings:
         const navEntry = entries[0];
-        const respOrActivStart = Math.max(navEntry.responseStart, navEntry.activationStart || 0);
-        agentRuntime[CONSTANTS.FBTWL] = Math.max(Math.round(navEntry.loadEventEnd - respOrActivStart), 0); // our "frontend" duration
-        handle('timing', ['load', Math.round(navEntry.loadEventEnd)], undefined, FEATURE_NAMES.pageViewTiming, this.ee);
-        agentRuntime[CONSTANTS.FBTDC] = Math.max(Math.round(navEntry.domContentLoadedEventEnd - respOrActivStart), 0); // our "dom processing" duration
+        this.timeToFirstByte = Math.max(value, this.timeToFirstByte);
+        this.firstByteToWindowLoad = Math.max(Math.round(navEntry.loadEventEnd - this.timeToFirstByte), this.firstByteToWindowLoad); // our "frontend" duration
+        this.firstByteToDomContent = Math.max(Math.round(navEntry.domContentLoadedEventEnd - this.timeToFirstByte), this.firstByteToDomContent); // our "dom processing" duration
 
         this.sendRum();
       });
     } else {
-      this.sendRum(); // timings either already in runtime from instrument or is meant to get 0'd.
+      // worker agent build does not get TTFB values, use default 0 values
+      this.sendRum();
     }
   }
-
-  getScheme() {
-    return getConfigurationValue(this.agentIdentifier, 'ssl') === false ? 'http' : 'https';
-  }
   sendRum() {
     const info = getInfo(this.agentIdentifier);
     const agentRuntime = getRuntime(this.agentIdentifier);
@@ -64,13 +53,13 @@ export class Aggregate extends AggregateBase {
     // Following PR #428, which demands that all agents send RUM call, these need to be sent even outside of the main window context where PerformanceTiming
     // or PerformanceNavigationTiming do not exists. Hence, they'll be filled in by 0s instead in, for example, worker threads that still init the PVE module.
     this.aggregator.store('measures', 'be', {
-      value: isBrowserScope ? agentRuntime[CONSTANTS.TTFB] : 0
+      value: this.timeToFirstByte
     });
     this.aggregator.store('measures', 'fe', {
-      value: isBrowserScope ? agentRuntime[CONSTANTS.FBTWL] : 0
+      value: this.firstByteToWindowLoad
     });
     this.aggregator.store('measures', 'dc', {
-      value: isBrowserScope ? agentRuntime[CONSTANTS.FBTDC] : 0
+      value: this.firstByteToDomContent
     });
     const queryParameters = {
       tt: info.ttGuid,
@@ -111,19 +100,8 @@ export class Aggregate extends AggregateBase {
         queryParameters.perf = stringify(perf);
       }
     }
-    try {
-      // PVTiming sends these too, albeit using web-vitals and slightly different; it's unknown why they're duplicated, but PVT should be the truth
-      var entries = globalScope.performance.getEntriesByType('paint');
-      entries.forEach(function (entry) {
-        if (!entry.startTime || entry.startTime <= 0) return;
-        if (entry.name === 'first-paint') {
-          queryParameters.fp = String(Math.floor(entry.startTime));
-        } else if (entry.name === 'first-contentful-paint') {
-          queryParameters.fcp = String(Math.floor(entry.startTime));
-        }
-        paintMetrics[entry.name] = Math.floor(entry.startTime); // this is consumed by Spa module
-      });
-    } catch (e) {}
+    queryParameters.fp = firstPaint.current.value;
+    queryParameters.fcp = firstContentfulPaint.current.value;
     harvester.send({
       endpoint: 'rum',
       payload: {

package/dist/esm/features/page_view_event/constants.js

@@ -1,5 +1,2 @@
 import { FEATURE_NAMES } from '../../loaders/features/features';
-export const FEATURE_NAME = FEATURE_NAMES.pageViewEvent;
-export const TTFB = 'firstbyte';
-export const FBTDC = 'domcontent';
-export const FBTWL = 'windowload';
+export const FEATURE_NAME = FEATURE_NAMES.pageViewEvent;

package/dist/esm/features/page_view_event/instrument/index.js

@@ -1,32 +1,10 @@
-import { handle } from '../../../common/event-emitter/handle';
-import { isiOS } from '../../../common/constants/runtime';
 import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
-import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { getRuntime } from '../../../common/config/config';
-import { onDOMContentLoaded, onWindowLoad } from '../../../common/window/load';
-import { now } from '../../../common/timing/now';
 export class Instrument extends InstrumentBase {
   static featureName = CONSTANTS.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME, auto);
-    if ((typeof PerformanceNavigationTiming === 'undefined' || isiOS) && typeof PerformanceTiming !== 'undefined') {
-      // For majority browser versions in which PNT exists, we can get load timings later from the nav entry (in the aggregate portion). At minimum, PT should exist for main window.
-      // *cli Mar'23 - iOS 15.2 & 15.4 testing in Sauce still fails with onTTFB. Hence, all iOS will fallback to this for now. Unknown if this is similar in nature to iOSBelow16 bug.
-      const agentRuntime = getRuntime(agentIdentifier);
-      agentRuntime[CONSTANTS.TTFB] = Math.max(Date.now() - agentRuntime.offset, 0);
-      onDOMContentLoaded(() => {
-        agentRuntime[CONSTANTS.FBTDC] = Math.max(now() - agentRuntime[CONSTANTS.TTFB], 0);
-      });
-      onWindowLoad(() => {
-        const timeNow = now();
-        agentRuntime[CONSTANTS.FBTWL] = Math.max(timeNow - agentRuntime[CONSTANTS.TTFB], 0);
-        handle('timing', ['load', timeNow], undefined, FEATURE_NAMES.pageViewTiming, this.ee);
-      });
-    }
-    // Else, inference: inside worker or some other env where these events are irrelevant. They'll get filled in with 0s in RUM call.
-
     this.importAggregator();
   }
 }