o11y 242.3.3 → 242.8.0

package/dist/modules/o11y/client/client.js

@@ -12,9 +12,9 @@ const headerParentSpanId = 'X-B3-ParentSpanId';
 const defaultActivityNameForFetch = 'fetch';
 const defaultActivityNameForXhrSend = 'xhr_send';
 class Tracing {
-    constructor(instr) {
-        this.instr = instr;
-        utility.requireArgument(instr, 'instr', 'object');
+    constructor(_instr) {
+        this._instr = _instr;
+        utility.requireArgument(_instr, '_instr', 'object');
     }
     static _getB3CompactFormat(traceId, spanId, isSampled, parentSpanId) {
         let b3 = `${traceId}-${spanId}`;
@@ -49,8 +49,8 @@ class Tracing {
     static getHeaders(traceId, spanId, isSampled, options) {
         utility.requireArgument(traceId, 'traceId', 'string');
         utility.requireArgument(spanId, 'spanId', 'string');
-        const useB3Headers = options && options.useB3Headers;
-        traceId = this._conformTextAsId(traceId, options && options.traceIdEffectiveLength !== undefined
+        const useB3Headers = options === null || options === void 0 ? void 0 : options.useB3Headers;
+        traceId = this._conformTextAsId(traceId, (options === null || options === void 0 ? void 0 : options.traceIdEffectiveLength) !== undefined
             ? options.traceIdEffectiveLength
             : useB3Headers
                 ? defaultTraceIdLengthB3
@@ -62,7 +62,7 @@ class Tracing {
             undefined;
         const headers = {};
         if (useB3Headers) {
-            const isCompact = options && options.useCompactHeader;
+            const isCompact = options === null || options === void 0 ? void 0 : options.useCompactHeader;
             if (isCompact) {
                 headers[headerB3] = this._getB3CompactFormat(traceId, spanId, isSampled, parentSpanId);
             }
@@ -210,7 +210,7 @@ class Tracing {
         if (options) {
             this._disableNetworkInstrumentation();
             const tracingOptions = typeof options === 'object' ? options : {};
-            this._enableNetworkInstrumentation(utility.definedValueOrDefault(tracingOptions.instrumentation, this.instr), utility.definedValueOrDefault(tracingOptions.logErrors, true), tracingOptions.activityName, utility.definedValueOrDefault(tracingOptions.useTracing, true), tracingOptions.tracingHeadersOptions);
+            this._enableNetworkInstrumentation(utility.definedValueOrDefault(tracingOptions.instrumentation, this._instr), utility.definedValueOrDefault(tracingOptions.logErrors, true), tracingOptions.activityName, utility.definedValueOrDefault(tracingOptions.useTracing, true), tracingOptions.tracingHeadersOptions);
         }
         else {
             this._disableNetworkInstrumentation();
@@ -466,9 +466,10 @@ const activityNoOp = Object.freeze(new ActivityNoOp());
 
 class DomEventHelpers {
     getInstrumentedEventData(eventData, handledBy, userPayload) {
+        var _a;
         const instrumentedEvent = {
             ownerComponent: handledBy.tagName,
-            parentComponent: (handledBy.parentElement && handledBy.parentElement.tagName) || undefined,
+            parentComponent: ((_a = handledBy.parentElement) === null || _a === void 0 ? void 0 : _a.tagName) || undefined,
             event: eventData,
             simplePath: utility.getXpath(handledBy)
         };
@@ -554,6 +555,12 @@ class ValidationEntry {
             case 7:
                 msg = 'Exceeded app limit for item count';
                 break;
+            case 12:
+                msg = 'Value must be an integer';
+                break;
+            case 13:
+                msg = 'Values like null or undefined are not allowed for items in repeated fields';
+                break;
             default:
                 msg = `Unknown error code: ${this.errorCode}`;
                 break;
@@ -568,113 +575,146 @@ class LogValidator {
         const schemaId = schemaUtil.getSchemaId(schema);
         const errorInfos = new Array();
         const nestedSchema = schemaUtil.getTypes(schema);
-        this.validateFields(errorInfos, [], data, nestedSchema[schemaTokens.message], nestedSchema, schemaId);
+        this._validateFields(errorInfos, [], data, nestedSchema[schemaTokens.message], nestedSchema, schemaId);
         if (errorInfos.length && !noThrow) {
             throw new Error(errorInfos[0].asMessage(schemaId));
         }
         return errorInfos;
     }
-    validateFields(errorInfos, fieldNames, data, message, descriptor, schemaId) {
+    _validateFields(errorInfos, fieldNames, data, message, descriptor, schemaId) {
         const oneofs = message.oneofs || {};
         const fields = message.fields || {};
         for (const key in data) {
             const value = data[key];
-            if (!this.isNullOrUndefinedOrEmpty(value)) {
-                const mft = (fieldType, rule) => this.matchFieldTypes(errorInfos, [...fieldNames, key], value, fieldType, descriptor, schemaId, key, rule);
+            if (value !== undefined && value !== null) {
+                const mft = (fieldType, isRepeated, isItem) => this._matchFieldTypes(errorInfos, [...fieldNames, key], value, fieldType, descriptor, schemaId, key, isRepeated, isItem);
                 if (oneofs[key]) {
                     mft(fields[oneofs[key].oneof[0]].type);
                 }
                 else if (fields[key]) {
-                    mft(fields[key].type, fields[key].rule);
+                    mft(fields[key].type, fields[key].rule === 'repeated');
                 }
             }
         }
     }
-    isNullOrUndefinedOrEmpty(val) {
-        return val === undefined || val === null || val === '';
-    }
-    matchFieldTypes(errorInfos, fieldNames, fieldDataValue, protobufType, descriptor, schemaId, key, rule) {
+    _matchFieldTypes(errorInfos, fieldNames, fieldDataValue, protobufType, descriptor, schemaId, key, isRepeated, isItem) {
         let errorCode;
-        if (rule === 'repeated') {
+        if (isRepeated) {
             if (Array.isArray(fieldDataValue)) {
                 if (fieldDataValue.length > maxItemCountAppLimit) {
                     errorCode = 7;
                 }
                 fieldDataValue.forEach((value, index) => {
-                    this.matchFieldTypes(errorInfos, [...fieldNames, index.toString()], value, protobufType, descriptor, schemaId, key);
+                    this._matchFieldTypes(errorInfos, [...fieldNames, index.toString()], value, protobufType, descriptor, schemaId, key, undefined, true);
                 });
             }
             else {
                 errorCode = 1;
             }
-            if (errorCode) {
-                errorInfos.push(new ValidationEntry(errorCode, fieldNames));
+        }
+        else if (fieldDataValue == null || fieldDataValue === undefined) {
+            if (isItem) {
+                errorCode = 13;
             }
-            return;
         }
-        let javaScriptType;
-        switch (protobufType) {
-            case 'string':
-                javaScriptType = 'string';
-                if (fieldDataValue.length > maxStringLengthAppLimit) {
-                    errorCode = 6;
-                }
-                break;
-            case 'bytes':
-                javaScriptType = 'object';
-                if (!(fieldDataValue instanceof Uint8Array)) {
-                    errorCode = 5;
-                }
-                break;
-            case 'bool':
-                javaScriptType = 'boolean';
-                break;
-            case 'uint32':
-                javaScriptType = 'number';
-                errorCode = this.checkNumberRange(fieldDataValue, minUnsigned, maxFourBytesUnsigned);
-                break;
-            case 'int32':
-            case 'sint32':
-            case 'fixed32':
-            case 'sfixed32':
-                javaScriptType = 'number';
-                errorCode = this.checkNumberRange(fieldDataValue, minFourBytes, maxFourBytes);
-                break;
-            case 'uint64':
-                javaScriptType = 'number';
-                errorCode = this.checkNumberRange(fieldDataValue, minUnsigned, maxEightBytesUnsigned);
-                break;
-            case 'fixed64':
-            case 'sfixed64':
-            case 'int64':
-            case 'sint64':
-                javaScriptType = 'number';
-                errorCode = this.checkNumberRange(fieldDataValue, minEightBytes, maxEightBytes);
-                break;
-            case 'double':
-            case 'float':
-                javaScriptType = 'number';
-                if (!Number.isFinite(fieldDataValue)) {
+        else {
+            let numOpts;
+            let javaScriptType;
+            switch (protobufType) {
+                case 'string':
+                    javaScriptType = 'string';
+                    if (fieldDataValue.length > maxStringLengthAppLimit) {
+                        errorCode = 6;
+                    }
+                    break;
+                case 'bytes':
+                    javaScriptType = 'object';
+                    if (!(fieldDataValue instanceof Uint8Array)) {
+                        errorCode = 5;
+                    }
+                    break;
+                case 'bool':
+                    javaScriptType = 'boolean';
+                    break;
+                case 'uint32':
+                    javaScriptType = 'number';
+                    numOpts = {
+                        min: minUnsigned,
+                        max: maxFourBytesUnsigned,
+                        isInt: true,
+                        isItem
+                    };
+                    break;
+                case 'int32':
+                case 'sint32':
+                case 'fixed32':
+                case 'sfixed32':
+                    javaScriptType = 'number';
+                    numOpts = {
+                        min: minFourBytes,
+                        max: maxFourBytes,
+                        isInt: true,
+                        isItem
+                    };
+                    break;
+                case 'uint64':
+                    javaScriptType = 'number';
+                    numOpts = {
+                        min: minUnsigned,
+                        max: maxEightBytesUnsigned,
+                        isInt: true,
+                        isItem
+                    };
+                    break;
+                case 'fixed64':
+                case 'sfixed64':
+                case 'int64':
+                case 'sint64':
+                    javaScriptType = 'number';
+                    numOpts = {
+                        min: minEightBytes,
+                        max: maxEightBytes,
+                        isInt: true,
+                        isItem
+                    };
+                    break;
+                case 'double':
+                case 'float':
+                    javaScriptType = 'number';
+                    numOpts = {
+                        min: Number.NEGATIVE_INFINITY,
+                        max: Number.POSITIVE_INFINITY,
+                        isInt: false,
+                        isItem
+                    };
+                    break;
+                default:
+                    if (new Set(Object.keys(descriptor)).has(protobufType)) {
+                        this._validateFields(errorInfos, fieldNames, fieldDataValue, descriptor[protobufType], descriptor, schemaId);
+                        javaScriptType = 'object';
+                    }
+                    break;
+            }
+            if (typeof fieldDataValue !== javaScriptType) {
+                errorInfos.push(new ValidationEntry(2, fieldNames, protobufType, typeof fieldDataValue));
+            }
+            else if (numOpts) {
+                if (numOpts.isInt && !Number.isFinite(fieldDataValue)) {
                     errorCode = 3;
                 }
-                break;
-            default:
-                if (new Set(Object.keys(descriptor)).has(protobufType)) {
-                    this.validateFields(errorInfos, fieldNames, fieldDataValue, descriptor[protobufType], descriptor, schemaId);
-                    javaScriptType = 'object';
+                else if (numOpts.isInt && !Number.isInteger(fieldDataValue)) {
+                    errorCode = 12;
                 }
-                break;
-        }
-        if (typeof fieldDataValue !== javaScriptType) {
-            errorInfos.push(new ValidationEntry(2, fieldNames, protobufType, typeof fieldDataValue));
+                else if (!(!numOpts.isInt && Number.isNaN(fieldDataValue)) &&
+                    !(fieldDataValue >= numOpts.min && fieldDataValue <= numOpts.max)) {
+                    errorCode = 4;
+                }
+            }
         }
         if (errorCode) {
             errorInfos.push(new ValidationEntry(errorCode, fieldNames));
         }
     }
-    checkNumberRange(value, min, max) {
-        return value > max || value < min ? 4 : undefined;
-    }
 }
 const logValidator = new LogValidator();
 
@@ -945,14 +985,9 @@ class MetricsImpl {
     }
 }
 
-class MockEvent {
-    constructor(type, composed, _composedPaths) {
-        this.type = type;
-        this.composed = composed;
-        this._composedPaths = _composedPaths;
-    }
-    composedPath() {
-        return this._composedPaths;
+class MockBase {
+    constructor() {
+        this.isMock = true;
     }
 }
 
@@ -1009,7 +1044,7 @@ class InstrumentationImpl {
         }
         return schemaUtil.makePayload(userSchema, userData, onlyIfBoth);
     }
-    getEffectiveRootId(options) {
+    _getEffectiveRootId(options) {
         var _a, _b;
         return ((_b = (_a = options === null || options === void 0 ? void 0 : options.instrumentationContext) === null || _a === void 0 ? void 0 : _a.rootId) !== null && _b !== void 0 ? _b : this._nextGen.getDefaultInstrumentationContext().rootId);
     }
@@ -1021,7 +1056,7 @@ class InstrumentationImpl {
             utility.requireArgumentIfDefined(options, 'options', 'object');
             const userPayload = this._wrapUserPayload(userSchemaOrText, userData);
             if (userPayload === null || userPayload === void 0 ? void 0 : userPayload.payload) {
-                this._logInternal(this.name, userPayload.schema, userPayload.payload, timestamp, this.getEffectiveRootId(options));
+                this._logInternal(this.name, userPayload.schema, userPayload.payload, timestamp, this._getEffectiveRootId(options));
             }
         });
     }
@@ -1039,7 +1074,7 @@ class InstrumentationImpl {
             ]);
             utility.requireArgumentIfDefined(userData, 'userData', 'object');
             utility.requireArgumentIfDefined(options, 'options', 'object');
-            const rootId = this.getEffectiveRootId(options);
+            const rootId = this._getEffectiveRootId(options);
             this._errorInternal(error, userSchemaOrText, userData, undefined, rootId);
         });
     }
@@ -1124,8 +1159,9 @@ class InstrumentationImpl {
     }
     domEvent(event, handledBy, userSchemaOrText, userData, options) {
         this._safety.tryCatch(() => {
+            var _a;
             const tsNow = utility.time().tsNow;
-            utility.requireArgument(event, 'event', [Event, MockEvent]);
+            utility.requireArgument(event, 'event', [Event, MockBase]);
             utility.requireArgument(handledBy, 'handledBy', [HTMLElement, 'object']);
             let htmlElement;
             if (handledBy instanceof HTMLElement) {
@@ -1133,7 +1169,7 @@ class InstrumentationImpl {
             }
             else {
                 handledBy = handledBy;
-                if (handledBy.template && handledBy.template.host instanceof HTMLElement) {
+                if (((_a = handledBy.template) === null || _a === void 0 ? void 0 : _a.host) instanceof HTMLElement) {
                     htmlElement = handledBy.template.host;
                 }
                 else {
@@ -1141,7 +1177,7 @@ class InstrumentationImpl {
                 }
             }
             const userPayload = this._wrapUserPayload(userSchemaOrText, userData, true);
-            const rootId = this.getEffectiveRootId(options);
+            const rootId = this._getEffectiveRootId(options);
             switch (event.type) {
                 case 'click': {
                     const mouseEvent = event;
@@ -1151,7 +1187,7 @@ class InstrumentationImpl {
                     }
                     const mouseEventData = domEventHelpers.getMouseEventData(mouseEvent);
                     const instrumentedEvent = domEventHelpers.getInstrumentedEventData(mouseEventData, htmlElement, userPayload);
-                    instrumentedEvent.auto = options && options._auto;
+                    instrumentedEvent.auto = options === null || options === void 0 ? void 0 : options._auto;
                     this._logInternal(this.name, instrumented_event, instrumentedEvent, tsNow, rootId);
                     break;
                 }
@@ -1357,7 +1393,7 @@ class AppInstrumentationImpl extends InstrumentationImpl {
     constructor(_nextGen, _name, _allowMulti) {
         super(_nextGen, _name);
         this._allowMulti = _allowMulti;
-        this._onRootActivityStoppedCallback = this.handleRootActivityStop.bind(this);
+        this._onRootActivityStoppedCallback = this._handleRootActivityStop.bind(this);
     }
     startRootActivity(name, rootId, isSampled) {
         return this._safety.tryCatchReturn(() => {
@@ -1374,7 +1410,7 @@ class AppInstrumentationImpl extends InstrumentationImpl {
             return newRootActivity;
         }, rootActivityNoOp);
     }
-    handleRootActivityStop(detail) {
+    _handleRootActivityStop(detail) {
         if (detail.stopReason === discarded) {
             return;
         }
@@ -1403,56 +1439,58 @@ class AppInstrumentationImpl extends InstrumentationImpl {
 
 const pathLimit = 5;
 class AutomaticClickTracker {
-    constructor(instrumentation, document) {
-        this.isActive = false;
-        this._boundClickListener = this.clickListener.bind(this);
-        utility.requireArgument(instrumentation, 'instrumentation');
-        utility.requireArgument(document, 'document');
-        this.instr = instrumentation;
-        this.document = document;
+    constructor(_instr, _doc) {
+        this._instr = _instr;
+        this._doc = _doc;
+        this._isActive = false;
+        this._boundClickListener = this._clickListener.bind(this);
+        utility.requireArgument(_instr, '_instr');
+        utility.requireArgument(_doc, '_doc');
     }
     activate() {
-        if (!this.isActive) {
-            this.document.addEventListener('click', this._boundClickListener, true);
-            this.isActive = true;
+        if (!this._isActive) {
+            this._doc.addEventListener('click', this._boundClickListener, true);
+            this._isActive = true;
         }
     }
     deactivate() {
-        if (this.isActive) {
-            this.document.removeEventListener('click', this._boundClickListener, true);
-            this.isActive = false;
+        if (this._isActive) {
+            this._doc.removeEventListener('click', this._boundClickListener, true);
+            this._isActive = false;
         }
     }
     markEventHandled(event) {
-        this.ignoredEvent = event;
+        this._ignoredEvent = event;
     }
-    clickListener(event) {
-        let eventTargets = event.composedPath && event.composedPath();
+    _clickListener(event) {
+        var _a;
+        let eventTargets = (_a = event.composedPath) === null || _a === void 0 ? void 0 : _a.call(event);
         if (!eventTargets || !eventTargets.length) {
             eventTargets = event.path;
         }
-        const handledBy = this.getClickableElement(eventTargets);
+        const handledBy = this._getClickableElement(eventTargets);
         if (handledBy) {
             setTimeout(() => {
-                if (event !== this.ignoredEvent) {
-                    this.instr.domEvent(event, handledBy, undefined, undefined, {
+                if (event !== this._ignoredEvent) {
+                    this._instr.domEvent(event, handledBy, undefined, undefined, {
                         _auto: true
                     });
                 }
             });
         }
     }
-    getClickableElement(path) {
+    _getClickableElement(path) {
+        var _a, _b;
         const limit = path ? Math.min(path.length, pathLimit) : 0;
         for (let x = 0; x < limit; x += 1) {
             const currentElement = path[x];
-            const tagName = currentElement.tagName && currentElement.tagName.toLowerCase();
+            const tagName = (_a = currentElement.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
             if (tagName === 'a' || tagName === 'button') {
                 return currentElement;
             }
             if (tagName === 'input') {
                 const inputElement = currentElement;
-                if (inputElement.type && inputElement.type.toLowerCase() === 'button') {
+                if (((_b = inputElement.type) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === 'button') {
                     return inputElement;
                 }
             }
@@ -1497,9 +1535,9 @@ class NextgenImpl {
         if (instr) {
             throw new Error(`The instrumentation name ${name} is already taken`);
         }
-        this._appInstr = new AppInstrumentationImpl(this, name, options && options.allowMultipleRootActivities);
+        this._appInstr = new AppInstrumentationImpl(this, name, options === null || options === void 0 ? void 0 : options.allowMultipleRootActivities);
         this._instruments.set(name, this._appInstr);
-        this._isBufferingEnabled = options && options.enableBuffering;
+        this._isBufferingEnabled = options === null || options === void 0 ? void 0 : options.enableBuffering;
         const tracing = new Tracing(this._appInstr);
         return {
             log: this._appInstr.log.bind(this._appInstr),
@@ -1538,7 +1576,8 @@ class NextgenImpl {
         return instr;
     }
     get appName() {
-        return this._appInstr && this._appInstr.name;
+        var _a;
+        return (_a = this._appInstr) === null || _a === void 0 ? void 0 : _a.name;
     }
     addLog(loggerName, schema, data, timestamp, rootId, pagePayload, appPayload) {
         this._sequence += 1;
@@ -1560,8 +1599,11 @@ class NextgenImpl {
         if (this._isBufferingEnabled) {
             this._buffer.push({ schema, data: utility.clone(data), logMeta });
         }
-        const eligibleCollectors = Array.from(this._logCollectors).filter((collector) => !this._forceDisabledLogCollectors.has(collector) &&
-            !(collector.getIsCollectDisabled && collector.getIsCollectDisabled()));
+        const eligibleCollectors = Array.from(this._logCollectors).filter((collector) => {
+            var _a;
+            return !this._forceDisabledLogCollectors.has(collector) &&
+                !((_a = collector.getIsCollectDisabled) === null || _a === void 0 ? void 0 : _a.call(collector));
+        });
         if (eligibleCollectors.length > 0) {
             for (const collector of eligibleCollectors) {
                 const dataClone = utility.clone(data);
@@ -1606,10 +1648,12 @@ class NextgenImpl {
         };
     }
     activateClickTracker() {
-        if (!this._autoClickTracker) {
-            this._autoClickTracker = new AutomaticClickTracker(this._appInstr, window.document);
+        if (typeof document !== 'undefined') {
+            if (!this._autoClickTracker) {
+                this._autoClickTracker = new AutomaticClickTracker(this._appInstr, document);
+            }
+            this._autoClickTracker.activate();
         }
-        this._autoClickTracker.activate();
     }
     deactivateClickTracker() {
         if (this._autoClickTracker) {
@@ -1639,20 +1683,20 @@ class NextgenImpl {
         }
         this._metricsCollector = collector;
         this._metricsCollector.receiveMetricsExtractors({
-            getAllUpCounters: this.getAllUpCounters.bind(this),
-            getAllValueRecorders: this.getAllValueRecorders.bind(this),
-            getAllBucketHistograms: this.getAllBucketHistograms.bind(this)
+            getAllUpCounters: this._getAllUpCounters.bind(this),
+            getAllValueRecorders: this._getAllValueRecorders.bind(this),
+            getAllBucketHistograms: this._getAllBucketHistograms.bind(this)
         });
     }
-    getAllUpCounters() {
+    _getAllUpCounters() {
         const arrOfArrs = Array.from(this._instruments.values()).map((instr) => instr.getUpCounters());
         return arrOfArrs.reduce((pv, cv) => pv.concat(cv), []);
     }
-    getAllValueRecorders() {
+    _getAllValueRecorders() {
         const arrOfArrs = Array.from(this._instruments.values()).map((instr) => instr.getValueRecorders());
         return arrOfArrs.reduce((pv, cv) => pv.concat(cv), []);
     }
-    getAllBucketHistograms() {
+    _getAllBucketHistograms() {
         const arrOfArrs = Array.from(this._instruments.values()).map((instr) => instr.getBucketHistograms());
         return arrOfArrs.reduce((pv, cv) => pv.concat(cv), []);
     }
@@ -1744,7 +1788,6 @@ class IdleDetectorImpl {
         this._logThreshold = defaultLogThreshold;
         this._endedTasks = new Array();
         this._pollableReport = new Array();
-        this._timerCheckQueued = 0;
         if (utility.requireArgumentIfDefined(options === null || options === void 0 ? void 0 : options.logThreshold, 'options.logThreshold', 'number')) {
             this._logThreshold = options.logThreshold;
         }
@@ -1755,9 +1798,9 @@ class IdleDetectorImpl {
             this._firstCallbackTime = utility.time().perfNow;
         }
         this._listeners.add(callback);
-        this.checkIfLoaded();
+        this._checkIfLoaded();
     }
-    reportTaskEnded(tasker) {
+    _reportTaskEnded(tasker) {
         if (this._listeners.size) {
             const snapshot = Object.assign({}, this._taskers.get(tasker));
             this._endedTasks.push(snapshot);
@@ -1765,7 +1808,7 @@ class IdleDetectorImpl {
     }
     declareNotifierTaskSingle(name) {
         utility.requireArgument(name, 'name', 'string');
-        const tasker = this.addTasker(name, 1);
+        const tasker = this._addTasker(name, 1);
         const retVal = {
             get isBusy() {
                 return tasker.isBusy;
@@ -1781,12 +1824,11 @@ class IdleDetectorImpl {
         utility.requireArgument(name, 'name', 'string');
         if (existingBusyCount !== undefined) {
             utility.requireArgument(existingBusyCount, 'existingBusyCount', 'number');
-            if (existingBusyCount < 0 ||
-                parseInt(existingBusyCount.toString(), 10) !== existingBusyCount) {
+            if (!Number.isInteger(existingBusyCount) || existingBusyCount < 0) {
                 throw new Error('existingBusyCount accepts only non-negative integers');
             }
         }
-        const tasker = this.addTasker(name, existingBusyCount);
+        const tasker = this._addTasker(name, existingBusyCount);
         const retVal = {
             get isBusy() {
                 return tasker.isBusy;
@@ -1808,11 +1850,11 @@ class IdleDetectorImpl {
         utility.requireArgument(isBusyChecker, 'isBusyChecker', 'function');
         this._busyCheckers.set(isBusyChecker, name);
     }
-    addTasker(name, existingBusyCount) {
+    _addTasker(name, existingBusyCount) {
         const tasker = new TaskerImpl(name, existingBusyCount, () => {
             this._taskers.get(tasker).end = utility.time().perfNow;
-            this.reportTaskEnded(tasker);
-            this.checkIfLoaded();
+            this._reportTaskEnded(tasker);
+            this._checkIfLoaded();
         }, () => {
             this._instr.error(`Overdone: ${tasker.name}`);
             utility.noProdThrow(`Tasker '${tasker.name}' is done too many times.`);
@@ -1824,10 +1866,10 @@ class IdleDetectorImpl {
         });
         return tasker;
     }
-    areAllNotifiersIdle() {
+    _areAllNotifiersIdle() {
         return !Array.from(this._taskers.keys()).some((t) => t.isBusy);
     }
-    getFirstBusyPollable() {
+    _getFirstBusyPollable() {
         const entry = Array.from(this._busyCheckers).find((entry) => {
             const isBusyChecker = entry[0];
             const name = entry[1];
@@ -1842,29 +1884,29 @@ class IdleDetectorImpl {
         });
         return entry ? entry[1] : undefined;
     }
-    checkIfLoaded() {
+    _checkIfLoaded() {
         if (!this._listeners.size) {
             return;
         }
         if (this._timerCheckQueued) {
-            window.clearTimeout(this._timerCheckQueued);
+            clearTimeout(this._timerCheckQueued);
         }
-        if (this.areAllNotifiersIdle()) {
-            this._timerCheckQueued = window.setTimeout(() => {
-                this._timerCheckQueued = window.setTimeout(() => {
-                    this.doubleCheck();
+        if (this._areAllNotifiersIdle()) {
+            this._timerCheckQueued = setTimeout(() => {
+                this._timerCheckQueued = setTimeout(() => {
+                    this._doubleCheck();
                 }, 40);
             }, 0);
         }
     }
-    doubleCheck() {
-        this._timerCheckQueued = 0;
-        if (this.areAllNotifiersIdle()) {
-            const pollableName = this.getFirstBusyPollable();
+    _doubleCheck() {
+        this._timerCheckQueued = undefined;
+        if (this._areAllNotifiersIdle()) {
+            const pollableName = this._getFirstBusyPollable();
             if (pollableName !== undefined) {
-                this.addToPollableReport(pollableName);
-                this._timerCheckQueued = window.setTimeout(() => {
-                    this.doubleCheck();
+                this._addToPollableReport(pollableName);
+                this._timerCheckQueued = setTimeout(() => {
+                    this._doubleCheck();
                 }, 15);
             }
             else {
@@ -1874,11 +1916,11 @@ class IdleDetectorImpl {
                 this._firstCallbackTime = undefined;
                 const endedTasks = this._endedTasks.splice(0);
                 const pollableReport = this._pollableReport.splice(0);
-                this.notify(listeners, maxDuration, endedTasks, pollableReport);
+                this._notify(listeners, maxDuration, endedTasks, pollableReport);
             }
         }
     }
-    addToPollableReport(name) {
+    _addToPollableReport(name) {
         const lastEntry = this._pollableReport.length
             ? this._pollableReport[this._pollableReport.length - 1]
             : undefined;
@@ -1892,7 +1934,7 @@ class IdleDetectorImpl {
             });
         }
     }
-    notify(listeners, maxDuration, taskReport, pollableReport) {
+    _notify(listeners, maxDuration, taskReport, pollableReport) {
         if (maxDuration >= this._logThreshold) {
             const logData = this._getReport(maxDuration, listeners.length, taskReport, pollableReport);
             this._instr.log(idle_detector_report, logData);
@@ -1978,7 +2020,7 @@ class ConsoleCollector {
     }
 }
 
-const version = '242.3.3';
+const version = '242.8.0';
 
 const idleDetector = new IdleDetectorImpl({
     logThreshold: 300