@dynatrace/react-native-plugin 2.305.1 → 2.309.1

package/lib/next/events/EventCreator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppStartEvent = exports.createErrorEvent = exports.createErrorCodeEvent = exports.createCrashEvent = void 0;
+const AppStartType_1 = require("../appstart/AppStartType");
+const createCrashEvent = (type, message, stacktrace, isFatal) => {
+    const event = {
+        'characteristics.has_crash': true,
+        'characteristics.has_error': true,
+        'error.is_fatal': isFatal,
+    };
+    if (type != null) {
+        event["exception.type"] = type;
+    }
+    if (message != null) {
+        event["exception.message"] = message;
+    }
+    if (stacktrace != null) {
+        event["exception.stack_trace"] = stacktrace;
+    }
+    return event;
+};
+exports.createCrashEvent = createCrashEvent;
+const createErrorCodeEvent = (errorName, errorCode) => {
+    const event = {
+        'characteristics.has_error': true,
+        'error.is_fatal': false,
+    };
+    if (errorName != null) {
+        event["name"] = errorName;
+    }
+    if (errorCode != null) {
+        event["error.code"] = errorCode;
+    }
+    return event;
+};
+exports.createErrorCodeEvent = createErrorCodeEvent;
+const createErrorEvent = (type, message, stacktrace) => {
+    const event = {
+        'characteristics.has_error': true,
+        'characteristics.has_exception': true,
+        'error.is_fatal': false,
+    };
+    if (type != null) {
+        event["exception.type"] = type;
+    }
+    if (message != null) {
+        event["exception.message"] = message;
+    }
+    if (stacktrace != null) {
+        event["exception.stack_trace"] = stacktrace;
+    }
+    return event;
+};
+exports.createErrorEvent = createErrorEvent;
+const createAppStartEvent = (appStartMeasurements) => {
+    const event = {
+        'characteristics.is_app_start': true,
+    };
+    let timings = [];
+    for (const { type, key } of AppStartType_1.AppStartTypeKeyMapping) {
+        if (appStartMeasurements[type] !== undefined) {
+            event[key] = appStartMeasurements[type];
+            timings.push(appStartMeasurements[type]);
+        }
+    }
+    timings = timings.sort((a, b) => a - b);
+    if (timings.length > 0) {
+        event["start_time"] = timings[0];
+        event["duration"] =
+            timings[timings.length - 1] - timings[0];
+    }
+    else {
+        return null;
+    }
+    return event;
+};
+exports.createAppStartEvent = createAppStartEvent;

package/lib/next/events/EventPipeline.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPipeline = void 0;
+const DynatraceBridge_1 = require("../../core/DynatraceBridge");
+const ConsoleLogger_1 = require("../../core/logging/ConsoleLogger");
+const BaseDataEventModifier_1 = require("./modifier/BaseDataEventModifier");
+const NonFiniteNumbersModifier_1 = require("./modifier/NonFiniteNumbersModifier");
+const ModifyEventValidation_1 = require("./modifier/ModifyEventValidation");
+const ViewInfoCreator_1 = require("./ViewInfoCreator");
+class EventPipelineImpl {
+    constructor() {
+        this.customEventModifierChain = new ModifyEventValidation_1.ModifyEventValidation();
+        this.logger = new ConsoleLogger_1.ConsoleLogger('EventPipeline');
+    }
+    getEventModifierChain(additionalData) {
+        return [
+            new BaseDataEventModifier_1.BaseDataEventModifier(this.viewInfo),
+            this.customEventModifierChain,
+            NonFiniteNumbersModifier_1.NonFiniteNumbersModifier,
+        ];
+    }
+    insertEvent(event, additionalData) {
+        this.logger.debug(`insertEvent(${JSON.stringify(event)}, ${JSON.stringify(additionalData)})`);
+        this.getEventModifierChain(additionalData).forEach((modifier) => {
+            try {
+                event = modifier.modifyEvent(event);
+            }
+            catch (error) {
+                if (event != null) {
+                    event["dt.rum.api.has_enrich_exception"] = true;
+                }
+            }
+        });
+        if (event != null) {
+            this.logger.debug(`forwardEvent(${JSON.stringify(event)})`);
+            DynatraceBridge_1.DynatraceNative.forwardEvent(event);
+        }
+    }
+    addEventModifier(eventModifier) {
+        this.logger.debug('addEventModifier()');
+        return this.customEventModifierChain.addEventModifier(eventModifier);
+    }
+    removeEventModifier(eventModifier) {
+        this.logger.debug('removeEventModifier()');
+        return this.customEventModifierChain.removeEventModifier(eventModifier);
+    }
+    generateViewData(name) {
+        this.logger.debug(`generateViewData(${name})`);
+        if (name != null) {
+            this.viewInfo = (0, ViewInfoCreator_1.createViewInfo)(name);
+        }
+    }
+    releaseViewData() {
+        this.viewInfo = undefined;
+    }
+}
+exports.EventPipeline = new EventPipelineImpl();

package/lib/next/events/EventTimestamp.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTimestamp = void 0;
+class EventTimestamp {
+    constructor(timestampProvider) {
+        this.duration = 0;
+        this.timestampProvider = timestampProvider;
+        this.startTimestamp = timestampProvider.getCurrentTimestamp();
+    }
+    getEventTimeInfo() {
+        return {
+            duration: this.duration,
+            start_time: this.startTimestamp,
+        };
+    }
+    setEndTimestamp(endTimestamp = this.timestampProvider.getCurrentTimestamp()) {
+        if (endTimestamp > this.startTimestamp) {
+            this.duration = endTimestamp - this.startTimestamp;
+        }
+        else {
+        }
+    }
+}
+exports.EventTimestamp = EventTimestamp;

package/lib/next/events/ViewInfoCreator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createViewInfo = void 0;
+const VIEW_ID_LENGTH = 16;
+const MAX_HEXADECIMAL_VALUE = 16;
+const ASCII_CODE_NUMERIC_0 = 48;
+const ASCII_CODE_A = 65;
+const NUMERICAL_CHARACTER_COUNT = 10;
+const OFFSET_A = ASCII_CODE_A - NUMERICAL_CHARACTER_COUNT;
+const createViewInfo = (name) => ({
+    ["view.id"]: createRandomHexString(VIEW_ID_LENGTH),
+    ["view.name"]: name,
+});
+exports.createViewInfo = createViewInfo;
+const createRandomHexString = (length) => createRandomString(length, MAX_HEXADECIMAL_VALUE);
+const createRandomString = (length, maxRange) => {
+    const resultArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        const randomInRange = Math.floor(Math.random() * maxRange);
+        const character = String.fromCharCode(randomInRange +
+            (randomInRange < NUMERICAL_CHARACTER_COUNT
+                ? ASCII_CODE_NUMERIC_0
+                : OFFSET_A));
+        resultArray.push(character);
+    }
+    return resultArray.join('');
+};

package/lib/next/events/modifier/BaseDataEventModifier.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDataEventModifier = void 0;
+const ConfigurationHandler_1 = require("../../../core/configuration/ConfigurationHandler");
+const ConsoleLogger_1 = require("../../../core/logging/ConsoleLogger");
+class BaseDataEventModifier {
+    constructor(viewInfo) {
+        this.viewInfo = viewInfo;
+        this.logger = new ConsoleLogger_1.ConsoleLogger('BaseDataEventModifier');
+    }
+    modifyEvent(event) {
+        if (event == null) {
+            this.logger.debug(`modifyEvent(${JSON.stringify(event)}): Event is null!`);
+            return event;
+        }
+        Object.assign(event, this.viewInfo);
+        event["dt.rum.event.source.type"] = 'react_native';
+        const bundleName = ConfigurationHandler_1.ConfigurationHandler.getBundleName();
+        if (bundleName !== undefined) {
+            event["app.react_native.bundle.name"] =
+                bundleName;
+        }
+        const bundleVersion = ConfigurationHandler_1.ConfigurationHandler.getBundleVersion();
+        if (bundleVersion !== undefined) {
+            event["app.react_native.bundle.version"] =
+                bundleVersion;
+        }
+        return event;
+    }
+}
+exports.BaseDataEventModifier = BaseDataEventModifier;

package/lib/next/events/modifier/EventLimitation.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLimitation = void 0;
+const ConsoleLogger_1 = require("../../../core/logging/ConsoleLogger");
+const EventSpecContstants_1 = require("../spec/EventSpecContstants");
+class EventLimitation {
+    constructor() {
+        this.logger = new ConsoleLogger_1.ConsoleLogger('EventLimitation');
+    }
+    limitEventEntries(customEntries) {
+        const fieldEntries = customEntries.slice();
+        fieldEntries.forEach(this.restrictingValueSize, this);
+        const validEntries = fieldEntries
+            .filter(this.isNotObject, this)
+            .filter(this.doesNotExceedKeySize, this)
+            .filter(this.isKeySyntaxAllowed, this);
+        if (fieldEntries.length !== validEntries.length) {
+            return validEntries;
+        }
+        else {
+            return fieldEntries;
+        }
+    }
+    limitEventProperties(eventEntries) {
+        const allowedEntries = [];
+        let propertyCounter = 0;
+        for (const [key, value] of eventEntries) {
+            if (key.startsWith("event_properties") ||
+                key.startsWith("session_properties")) {
+                propertyCounter++;
+                if (propertyCounter > EventSpecContstants_1.MAX_CUSTOM_EVENT_FIELDS) {
+                    this.logger.debug(`limitEventProperties(): Dropped ${key} because overall property limit is reached!`);
+                    continue;
+                }
+            }
+            allowedEntries.push([key, value]);
+        }
+        return allowedEntries;
+    }
+    isKeySyntaxAllowed(entry) {
+        const [key] = entry;
+        const rV = EventSpecContstants_1.KEY_NAME_REGEX.test(key);
+        if (!rV) {
+            this.logger.debug(`isKeySyntaxAllowed(): Filtering key ${key} as it doesnt fulfill character rules!`);
+        }
+        return rV;
+    }
+    restrictingValueSize(entry) {
+        const [key, value] = entry;
+        if (typeof value === 'string' &&
+            value.length > EventSpecContstants_1.MAX_CUSTOM_EVENT_VALUE_LENGTH) {
+            this.logger.debug(`restrictingValueSize(): Limiting value of ${key} as maximum value length (${EventSpecContstants_1.MAX_CUSTOM_EVENT_VALUE_LENGTH}) is reached!`);
+            entry[1] = value.slice(0, EventSpecContstants_1.MAX_CUSTOM_EVENT_VALUE_LENGTH);
+        }
+    }
+    doesNotExceedKeySize([key]) {
+        if (key.length <= EventSpecContstants_1.MAX_CUSTOM_EVENT_KEY_LENGTH) {
+            return true;
+        }
+        else {
+            this.logger.debug(`doesNotExceedKeySize(): Dropping key ${key} as maximum key length (${EventSpecContstants_1.MAX_CUSTOM_EVENT_KEY_LENGTH}) is reached!`);
+            return false;
+        }
+    }
+    isNotObject([, val]) {
+        return typeof val !== 'object' || val === null;
+    }
+}
+exports.EventLimitation = EventLimitation;

package/lib/next/events/modifier/EventModifierUtil.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containEventPropertiesInArray = exports.containEventProperties = exports.containSessionProperties = exports.trimStringValuesInObject = exports.trimString = exports.isObject = exports.flattenAdditionalData = void 0;
+const MAX_STRING_LENGTH_FOR_VALUES = 5000;
+const flattenAdditionalData = (obj, parent, res = {}) => {
+    for (const key in obj) {
+        const propName = parent != null ? parent + '.' + key : key;
+        if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+            (0, exports.flattenAdditionalData)(obj[key], propName, res);
+        }
+        else {
+            res[propName] = obj[key];
+        }
+    }
+    return res;
+};
+exports.flattenAdditionalData = flattenAdditionalData;
+const isObject = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    return Object.prototype.toString.call(obj) === '[object Object]';
+};
+exports.isObject = isObject;
+const trimString = (str, maxLength = MAX_STRING_LENGTH_FOR_VALUES) => {
+    const stringToTrim = str.toString();
+    if (stringToTrim.length <= maxLength) {
+        return stringToTrim;
+    }
+    else {
+        return stringToTrim.substring(0, maxLength);
+    }
+};
+exports.trimString = trimString;
+const trimStringValuesInObject = (jsonData) => {
+    for (const key in jsonData) {
+        if (Object.prototype.hasOwnProperty.call(jsonData, key)) {
+            jsonData[key] = trimStringValue(jsonData[key]);
+        }
+    }
+    return jsonData;
+};
+exports.trimStringValuesInObject = trimStringValuesInObject;
+const containSessionProperties = (jsonData) => {
+    for (const key in jsonData) {
+        if (key.startsWith(`${"session_properties"}.`)) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.containSessionProperties = containSessionProperties;
+const containEventProperties = (jsonData) => {
+    for (const key in jsonData) {
+        if (key.startsWith(`${"event_properties"}.`)) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.containEventProperties = containEventProperties;
+const containEventPropertiesInArray = (eventEntries) => {
+    for (const [key, value] of eventEntries) {
+        if (key.startsWith(`${"event_properties"}.`)) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.containEventPropertiesInArray = containEventPropertiesInArray;
+const trimStringValuesInArray = (arrayData) => {
+    arrayData.forEach((value, index, array) => {
+        array[index] = trimStringValue(value);
+    });
+    return arrayData;
+};
+const trimStringValue = (data) => {
+    if (typeof data === 'string') {
+        return (0, exports.trimString)(data);
+    }
+    else if (Array.isArray(data)) {
+        return trimStringValuesInArray(data);
+    }
+    else if ((0, exports.isObject)(data)) {
+        return (0, exports.trimStringValuesInObject)(data);
+    }
+    return data;
+};

package/lib/next/events/modifier/IEventModifier.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/next/events/modifier/ModifyEventValidation.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModifyEventValidation = void 0;
+const ConsoleLogger_1 = require("../../../core/logging/ConsoleLogger");
+const EventSpecContstants_1 = require("../spec/EventSpecContstants");
+const EventLimitation_1 = require("./EventLimitation");
+const EventModifierUtil_1 = require("./EventModifierUtil");
+class ModifyEventValidation {
+    constructor() {
+        this.customEventModifierChain = [];
+        this.logger = new ConsoleLogger_1.ConsoleLogger('ModifyEventValidation');
+    }
+    addEventModifier(eventModifier) {
+        this.customEventModifierChain.push(eventModifier);
+        return eventModifier;
+    }
+    removeEventModifier(eventModifier) {
+        const index = this.customEventModifierChain.indexOf(eventModifier);
+        if (index !== -1) {
+            this.customEventModifierChain.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    modifyEvent(event) {
+        if (this.customEventModifierChain.length > 0) {
+            const eventCopy = Object.assign({}, event);
+            let exceptionOccured = false;
+            this.customEventModifierChain.forEach((modifier) => {
+                try {
+                    event = modifier.modifyEvent(event);
+                }
+                catch (error) {
+                    if (event != null) {
+                        exceptionOccured = true;
+                    }
+                }
+            });
+            event = this.sanitizeUserEnrichedEvent(eventCopy, event, exceptionOccured);
+        }
+        return event;
+    }
+    isPropertiesAllowed(key, hasSessionPropertyCharacteristics) {
+        if (hasSessionPropertyCharacteristics) {
+            if (key.startsWith(`${"event_properties"}.`)) {
+                this.logger.debug(`isPropertiesAllowed(): Filtering key ${key} as usage of event properties is not allowed!`);
+                return true;
+            }
+        }
+        else {
+            if (key.startsWith(`${"session_properties"}.`)) {
+                this.logger.debug(`isPropertiesAllowed(): Filtering key ${key} as usage of session properties is not allowed!`);
+                return true;
+            }
+        }
+        return false;
+    }
+    isKeyNameForbidden(key) {
+        for (const namespace of EventSpecContstants_1.MODIFY_EVENT_WHITELIST_NAMESPACE) {
+            if (key.startsWith(`${namespace}.`)) {
+                return false;
+            }
+        }
+        if (EventSpecContstants_1.MODIFY_EVENT_WHITELIST_FIELDS.includes(key)) {
+            return false;
+        }
+        this.logger.debug(`isKeyNameForbidden(): Filtering key ${key} as this field is reserved and must not be overridden!`);
+        return true;
+    }
+    sanitizeUserEnrichedEvent(originalEvent, userEnrichedEvent, externalException) {
+        if (!(0, EventModifierUtil_1.isObject)(userEnrichedEvent)) {
+            this.logger.debug(`sanitizeUserEnrichedEvent(${originalEvent}, ${userEnrichedEvent}): Enriched event is not an object`);
+            return originalEvent;
+        }
+        if (userEnrichedEvent === originalEvent) {
+            this.logger.debug(`sanitizeUserEnrichedEvent(${originalEvent}, ${userEnrichedEvent}): Event has not been changed`);
+            return originalEvent;
+        }
+        let overriddenKeys = originalEvent["dt.rum.overridden_keys"];
+        if (overriddenKeys == null) {
+            overriddenKeys = [];
+        }
+        const userEnrichedEventEntries = Object.entries(userEnrichedEvent);
+        const validEntries = this.determineValidEntries(userEnrichedEventEntries, originalEvent, overriddenKeys);
+        const restoredEntries = this.restoreRemovedEntries(Object.entries(originalEvent), userEnrichedEvent, overriddenKeys);
+        const validAndRestoredEntries = validEntries.concat(restoredEntries);
+        const { baseEntries, addedEntries } = this.determineAddedEntries(originalEvent, validAndRestoredEntries);
+        const limitedEntries = new EventLimitation_1.EventLimitation().limitEventEntries(addedEntries);
+        if (originalEvent["characteristics.has_event_properties"] === undefined &&
+            (0, EventModifierUtil_1.containEventPropertiesInArray)(limitedEntries)) {
+            limitedEntries.push([
+                "characteristics.has_event_properties",
+                true,
+            ]);
+        }
+        const finalEntries = baseEntries.concat(limitedEntries);
+        const sizedEntries = new EventLimitation_1.EventLimitation().limitEventProperties(finalEntries);
+        sizedEntries.push([
+            "dt.rum.api.has_dropped_fields",
+            sizedEntries.length < userEnrichedEventEntries.length,
+        ]);
+        if (Array.isArray(overriddenKeys) && overriddenKeys.length > 0) {
+            sizedEntries.push([
+                "dt.rum.overridden_keys",
+                overriddenKeys,
+            ]);
+        }
+        if (externalException) {
+            sizedEntries.push([
+                "dt.rum.api.has_enrich_exception",
+                true,
+            ]);
+        }
+        return Object.fromEntries(sizedEntries);
+    }
+    determineValidEntries(userEnrichedEntries, originalJSONEvent, overriddenKeys) {
+        const newEntries = [];
+        for (const [prop, value] of userEnrichedEntries) {
+            const originalValue = originalJSONEvent[prop];
+            if (!this.isModified(originalValue, value)) {
+                newEntries.push([prop, value]);
+                continue;
+            }
+            if (this.isPropertiesAllowed(prop, originalJSONEvent["characteristics.has_session_properties"] === true)) {
+                continue;
+            }
+            const isNewlyAdded = typeof originalValue === 'undefined';
+            const isForbiddenKey = this.isKeyNameForbidden(prop);
+            if (isForbiddenKey) {
+                if (!isNewlyAdded) {
+                    newEntries.push([prop, originalValue]);
+                }
+                continue;
+            }
+            if (!isNewlyAdded && !overriddenKeys.includes(prop)) {
+                overriddenKeys.push(prop);
+            }
+            newEntries.push([prop, value]);
+        }
+        return newEntries;
+    }
+    isModified(oldValue, newValue) {
+        if (Array.isArray(oldValue)) {
+            return (!Array.isArray(newValue) ||
+                oldValue.length !== newValue.length ||
+                !oldValue.every((item, index) => !this.isModified(item, newValue[index])));
+        }
+        if ((0, EventModifierUtil_1.isObject)(oldValue)) {
+            const oldEntries = Object.entries(oldValue);
+            return (!(0, EventModifierUtil_1.isObject)(newValue) ||
+                Object.entries(newValue).length !== oldEntries.length ||
+                !oldEntries.every(([prop, value]) => !this.isModified(value, newValue[prop])));
+        }
+        return oldValue !== newValue;
+    }
+    restoreRemovedEntries(originalEntries, userEnrichedEvent, overriddenKeys) {
+        const restoredEntries = [];
+        for (const [prop, value] of originalEntries) {
+            if (typeof userEnrichedEvent[prop] !== 'undefined') {
+                continue;
+            }
+            if (this.isKeyNameForbidden(prop)) {
+                restoredEntries.push([prop, value]);
+            }
+            else if (!overriddenKeys.includes(prop)) {
+                overriddenKeys.push(prop);
+            }
+        }
+        return restoredEntries;
+    }
+    determineAddedEntries(originalJSONEvent, userEnrichedEntries) {
+        const resultEntries = {
+            baseEntries: [],
+            addedEntries: [],
+        };
+        return userEnrichedEntries.reduce((entries, entry) => {
+            if (Object.prototype.hasOwnProperty.call(originalJSONEvent, entry[0])) {
+                entries.baseEntries.push(entry);
+            }
+            else {
+                entries.addedEntries.push(entry);
+            }
+            return entries;
+        }, resultEntries);
+    }
+}
+exports.ModifyEventValidation = ModifyEventValidation;

package/lib/next/events/modifier/NonFiniteNumbersModifier.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonFiniteNumbersModifier = void 0;
+const ConsoleLogger_1 = require("../../../core/logging/ConsoleLogger");
+const EventModifierUtil_1 = require("./EventModifierUtil");
+class NonFiniteNumbersModifierImpl {
+    constructor() {
+        this.logger = new ConsoleLogger_1.ConsoleLogger('NonFiniteNumbersModifier');
+    }
+    modifyEvent(event) {
+        if (event != null && this.eventHasNonFiniteNumbers(event)) {
+            event["dt.rum.has_nfn_values"] = true;
+        }
+        return event;
+    }
+    eventHasNonFiniteNumbers(obj) {
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key) &&
+                this.valueHasNonFiniteNumber(obj[key])) {
+                this.logger.debug(`eventHasNonFiniteNumbers() - ${key} contains non-finite numbers: ${obj[key]} changed to null!`);
+                return true;
+            }
+        }
+        return false;
+    }
+    valueHasNonFiniteNumber(val) {
+        if (typeof val === 'function') {
+            return true;
+        }
+        if (Array.isArray(val)) {
+            return this.arrayHasNonFiniteNumbers(val);
+        }
+        if ((0, EventModifierUtil_1.isObject)(val)) {
+            return this.eventHasNonFiniteNumbers(val);
+        }
+        return !this.isFinitePrimitive(val);
+    }
+    arrayHasNonFiniteNumbers(arr) {
+        for (const val of arr) {
+            if (this.valueHasNonFiniteNumber(val)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isFinitePrimitive(value) {
+        return typeof value !== 'number' || isFinite(value);
+    }
+}
+exports.NonFiniteNumbersModifier = new NonFiniteNumbersModifierImpl();