@microsoft/applicationinsights-core-js 3.0.0-beta.2208-03 → 3.0.0-beta.2208-16

package/src/JavaScriptSDK/HelperFuncs.ts

@@ -1,51 +1,33 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
+import { ObjAssign, ObjClass, ObjHasOwnProperty, ObjProto, strShimFunction, strShimPrototype } from "@microsoft/applicationinsights-shims";
 import {
-    ObjAssign, ObjClass, ObjDefineProperty, ObjHasOwnProperty, ObjProto, strShimFunction, strShimObject, strShimPrototype, strShimUndefined,
-    throwTypeError
-} from "@microsoft/applicationinsights-shims";
+    arrForEach, isArray, isBoolean, isError, isFunction, isNullOrUndefined, isObject, isString, isUndefined, objDeepFreeze,
+    objDefineAccessors, objForEachKey, objHasOwnProperty, strIndexOf, throwUnsupported
+} from "@nevware21/ts-utils";
 import { STR_EMPTY } from "./InternalConstants";
 
 // RESTRICT and AVOID circular dependencies you should not import other contained modules or export the contents of this file directly
 
-// Added to help with minfication
+// Added to help with minification
+const cString = "String";
+const cObject = "Object";
 const strToISOString = "toISOString";
-const cStrEndsWith = "endsWith";
-const cStrStartsWith = "startsWith";
-const strIndexOf = "indexOf";
 const strMap = "map";
-const strReduce = "reduce";
-const cStrTrim = "trim";
 const strToString = "toString";
-
-/**
- * Constant string defined to support minimization
- * @ignore
- */
-const str__Proto = "__proto__";
+const strGetPrototypeOf = "getPrototypeOf";
 
 /**
   * Constant string defined to support minimization
   * @ignore
   */
 const strConstructor = "constructor";
- 
-const _objDefineProperty = ObjDefineProperty;
-const _objFreeze = ObjClass.freeze;
-const _objSeal = ObjClass.seal;
-const _objKeys = ObjClass.keys;
-
-const StringProto = String[strShimPrototype];
-const _strTrim = StringProto[cStrTrim];
-const _strEndsWith = StringProto[cStrEndsWith];
-const _strStartsWith = StringProto[cStrStartsWith];
 
 const DateProto = Date[strShimPrototype];
-const _dataToISOString = DateProto[strToISOString];
-const _isArray = Array.isArray;
-const _objToString = ObjProto[strToString];
+const _dateToISOString = DateProto[strToISOString] || _polyfillRequired("Date", strToISOString);
+const _objToString = ObjProto[strToString] || _polyfillRequired(cObject, strToString);
 
-const _fnToString = ObjHasOwnProperty[strToString];
+const _fnToString = ObjHasOwnProperty[strToString] || _polyfillRequired(cString, strToString);
 // Cache what this browser reports as the object function constructor (as a string)
 const _objFunctionString = _fnToString.call(ObjClass);
 
@@ -53,76 +35,26 @@ const rCamelCase = /-([a-z])/g;
 const rNormalizeInvalid = /([^\w\d_$])/g;
 const rLeadingNumeric = /^(\d+[\w\d_$])/;
 
-
-/**
- * Pre-lookup to check if we are running on a modern browser (i.e. not IE8)
- * @ignore
- */
-let _objGetPrototypeOf = Object["getPrototypeOf"];
-
-/**
-  * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.
-  * @ignore
-  */
-export function _getObjProto(target:any) {
-    if (target) {
-        // This method doesn't existing in older browsers (e.g. IE8)
-        if (_objGetPrototypeOf) {
-            return _objGetPrototypeOf(target);
-        }
- 
-        // target[Constructor] May break if the constructor has been changed or removed
-        let newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
-        if(newProto) {
-            return newProto;
-        }
+function _polyfillRequired(object:string, name: string): any {
+    return function() {
+        throwUnsupported("Polyfill required for [" + name + "]");
     }
- 
-    return null;
 }
 
+export let _getObjProto = Object[strGetPrototypeOf] || _polyfillRequired(cObject, strGetPrototypeOf);
+
 export function objToString(obj: any) {
     return _objToString.call(obj);
 }
 
-export function isTypeof(value: any, theType: string): boolean {
-    return typeof value === theType;
-}
-
-export function isUndefined(value: any): value is undefined {
-    return value === undefined || typeof value === strShimUndefined;
-}
-
 export function isNotUndefined<T>(value: T): value is T {
     return !isUndefined(value);
 }
 
-export function isNullOrUndefined(value: any): value is null | undefined {
-    return (value === null || isUndefined(value));
-}
-
 export function isNotNullOrUndefined<T>(value: T): value is T {
     return !isNullOrUndefined(value);
 }
 
-export function hasOwnProperty(obj: any, prop: string): boolean {
-    return !!(obj && ObjHasOwnProperty.call(obj, prop));
-}
-
-export function isObject<T>(value: T): value is T {
-    // Changing to inline for performance
-    return !!(value && typeof value === strShimObject);
-}
-
-export function isFunction(value: any): value is Function {
-    // Changing to inline for performance
-    return !!(value && typeof value === strShimFunction);
-}
-
-export function isPromiseLike<T>(value: any): value is PromiseLike<T> {
-    return value && isFunction(value.then);
-}
-
 /**
  * Validates that the string name conforms to the JS IdentifierName specification and if not
  * normalizes the name so that it would. This method does not identify or change any keywords
@@ -148,178 +80,19 @@ export function normalizeJsName(name: string): string {
     return value;
 }
 
-/**
- * This is a helper function for the equivalent of arForEach(objKeys(target), callbackFn), this is a
- * performance optimization to avoid the creation of a new array for large objects
- * @param target The target object to find and process the keys
- * @param callbackfn The function to call with the details
- */
-export function objForEachKey<T = any>(target: T, callbackfn: (name: string, value: T[keyof T]) => void) {
-    if (target) {
-        for (let prop in target) {
-            if (ObjHasOwnProperty.call(target, prop)) {
-                callbackfn.call(target, prop, target[prop]);
-            }
-        }
-    }
-}
-
-/**
- * The strEndsWith() method determines whether a string ends with the characters of a specified string, returning true or false as appropriate.
- * @param value - The value to check whether it ends with the search value.
- * @param search - The characters to be searched for at the end of the value.
- * @returns true if the given search value is found at the end of the string, otherwise false.
- */
-export function strEndsWith(value: string, search: string) {
-    let result = false;
-    if (value && search && !(result = value === search)) {
-        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-        result = _strEndsWith ? value[cStrEndsWith](search) : _strEndsWithPoly(value, search);
-    }
-
-    return result;
-}
-
-/**
- * The _strEndsWith() method determines whether a string ends with the characters of a specified string, returning true or false as appropriate.
- * @param value - The value to check whether it ends with the search value.
- * @param search - The characters to be searched for at the end of the value.
- * @returns true if the given search value is found at the end of the string, otherwise false.
- */
-export function _strEndsWithPoly(value: string, search: string) {
-    let result = false;
-    let searchLen = search ? search.length : 0;
-    let valLen = value ? value.length : 0;
-    if (searchLen && valLen && valLen >= searchLen && !(result = value === search)) {
-        let pos = valLen - 1;
-        for (let lp = searchLen - 1; lp >= 0; lp--) {
-            if (value[pos] != search[lp]) {
-                return false;
-            }
-            pos--;
-        }
-
-        result = true;
-    }
-
-    return result;
-}
-
-/**
- * The strStartsWith() method determines whether a string starts with the characters of the specified string, returning true or false as appropriate.
- * @param value - The value to check whether it ends with the search value.
- * @param checkValue - The characters to be searched for at the start of the value.
- * @returns true if the given search value is found at the start of the string, otherwise false.
- */
-export function strStartsWith(value: string, checkValue: string) {
-    let result = false;
-    if (value && checkValue && !(result = value === checkValue)) {
-        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-        result = _strStartsWith ? value[cStrStartsWith](checkValue) : _strStartsWithPoly(value, checkValue);
-    }
-
-    return result;
-}
-
-/**
- * The strStartsWith() method determines whether a string starts with the characters of the specified string, returning true or false as appropriate.
- * @param value - The value to check whether it ends with the search value.
- * @param checkValue - The characters to be searched for at the start of the value.
- * @returns true if the given search value is found at the start of the string, otherwise false.
- */
-export function _strStartsWithPoly(value: string, checkValue: string) {
-    // Using helper for performance and because string startsWith() is not available on IE
-    let result = false;
-    let chkLen = checkValue ? checkValue.length : 0;
-    if (value && chkLen && value.length >= chkLen && !(result = value === checkValue)) {
-        for (let lp = 0; lp < chkLen; lp++) {
-            if (value[lp] !== checkValue[lp]) {
-                return false;
-            }
-        }
-
-        result = true;
-    }
-
-    return result;
-}
-
 /**
  * A simple wrapper (for minification support) to check if the value contains the search string.
  * @param value - The string value to check for the existence of the search value
  * @param search - The value search within the value
  */
-export function strContains(value: string, search: string) {
+export function strContains(value: string, search: string): boolean {
     if (value && search) {
-        return value.indexOf(search) !== -1;
+        return strIndexOf(value, search) !== -1;
     }
 
     return false;
 }
 
-/**
- * Check if an object is of type Date
- */
-export function isDate(obj: any): obj is Date {
-    return !!(obj && _objToString.call(obj) === "[object Date]");
-}
-
-/**
- * Check if an object is of type Array with optional generic T, the generic type is not validated
- * and exists to help with TypeScript validation only.
- */
-export let isArray: <T = any>(obj: any) => obj is Array<T> = _isArray || _isArrayPoly;
-function _isArrayPoly<T = any>(obj: any): obj is Array<T> {
-    return !!(obj && _objToString.call(obj) === "[object Array]");
-}
-
-/**
- * Check if an object is of type Error
- */
-export function isError(obj: any): obj is Error {
-    return !!(obj && _objToString.call(obj) === "[object Error]");
-}
-
-/**
- * Checks if the type of value is a string.
- * @param {any} value - Value to be checked.
- * @return {boolean} True if the value is a string, false otherwise.
- */
-export function isString(value: any): value is string {
-    // Changing to inline for performance
-    return typeof value === "string";
-}
-
-/**
- * Checks if the type of value is a number.
- * @param {any} value - Value to be checked.
- * @return {boolean} True if the value is a number, false otherwise.
- */
-export function isNumber(value: any): value is number {
-    // Changing to inline for performance
-    return typeof value === "number";
-}
-
-/**
- * Checks if the type of value is a boolean.
- * @param {any} value - Value to be checked.
- * @return {boolean} True if the value is a boolean, false otherwise.
- */
-export function isBoolean(value: any): value is boolean {
-    // Changing to inline for performance
-    return typeof value === "boolean";
-}
-
-/**
- * Checks if the type of value is a Symbol.
- * This only returns a boolean as returning value is Symbol will cause issues for older TypeScript consumers
- * @param {any} value - Value to be checked.
- * @return {boolean} True if the value is a Symbol, false otherwise.
- */
-export function isSymbol(value: any): boolean {
-    return typeof value === "symbol";
-}
-
 /**
  * Checks if the type of the value is a normal plain object (not a null or data)
  * @param value
@@ -329,7 +102,7 @@ export function isPlainObject(value: any): boolean {
 
     if (value && typeof value === "object") {
         // Inlining _objGetPrototypeOf for performance to avoid an additional function call
-        let proto = _objGetPrototypeOf ? _objGetPrototypeOf(value) : _getObjProto(value);
+        let proto = _getObjProto(value);
         if (!proto) {
             // No prototype found so this is a plain Object eg. 'Object.create(null)'
             result = true;
@@ -350,285 +123,10 @@ export function isPlainObject(value: any): boolean {
  * Convert a date to I.S.O. format in IE8
  */
 export function toISOString(date: Date) {
-    if (date) {
-        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-        return _dataToISOString ? date[strToISOString]() : _toISOStringPoly(date);
-    }
-}
-
-/**
- * Convert a date to I.S.O. format in IE8
- */
-export function _toISOStringPoly(date: Date) {
-    if (date && date.getUTCFullYear) {
-        const pad = (num: number) => {
-            let r = String(num);
-            if (r.length === 1) {
-                r = "0" + r;
-            }
-
-            return r;
-        }
-
-        return date.getUTCFullYear()
-            + "-" + pad(date.getUTCMonth() + 1)
-            + "-" + pad(date.getUTCDate())
-            + "T" + pad(date.getUTCHours())
-            + ":" + pad(date.getUTCMinutes())
-            + ":" + pad(date.getUTCSeconds())
-            + "." + String((date.getUTCMilliseconds() / 1000).toFixed(3)).slice(2, 5)
-            + "Z";
-    }
-}
-
-/**
- * Performs the specified action for each element in an array. This helper exists to avoid adding a polyfil for older browsers
- * that do not define Array.prototype.xxxx (eg. ES3 only, IE8) just in case any page checks for presence/absence of the prototype
- * implementation. Note: For consistency this will not use the Array.prototype.xxxx implementation if it exists as this would
- * cause a testing requirement to test with and without the implementations
- * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. It can return -1 to break out of the loop
- * @param thisArg  [Optional] An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
- */
-export function arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => undefined | void | number, thisArg?: any): void {
-    let len = arr.length;
-    try {
-        for (let idx = 0; idx < len; idx++) {
-            if (idx in arr) {
-                if (callbackfn.call(thisArg || arr, arr[idx], idx, arr) === -1) {
-                    break;
-                }
-            }
-        }
-    } catch (e) {
-        // This can happen with some native browser objects, but should not happen for the type we are checking for
-    }
-}
-
-/**
- * Returns the index of the first occurrence of a value in an array. This helper exists to avoid adding a polyfil for older browsers
- * that do not define Array.prototype.xxxx (eg. ES3 only, IE8) just in case any page checks for presence/absence of the prototype
- * implementation. Note: For consistency this will not use the Array.prototype.xxxx implementation if it exists as this would
- * cause a testing requirement to test with and without the implementations
- * @param searchElement The value to locate in the array.
- * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
- */
-export function arrIndexOf<T>(arr: T[], searchElement: T, fromIndex?: number): number {
-    if (arr) {
-        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-        if (arr[strIndexOf]) {
-            return arr[strIndexOf](searchElement, fromIndex);
-        }
-
-        let len = arr.length;
-        let from = fromIndex || 0;
-        try {
-            for (let lp = Math.max(from >= 0 ? from : len - Math.abs(from), 0); lp < len; lp++) {
-                if (lp in arr && arr[lp] === searchElement) {
-                    return lp;
-                }
-            }
-        } catch (e) {
-            // This can happen with some native browser objects, but should not happen for the type we are checking for
-        }
-    }
-
-    return -1;
-}
-
-/**
- * Calls a defined callback function on each element of an array, and returns an array that contains the results. This helper exists
- * to avoid adding a polyfil for older browsers that do not define Array.prototype.xxxx (eg. ES3 only, IE8) just in case any page
- * checks for presence/absence of the prototype implementation. Note: For consistency this will not use the Array.prototype.xxxx
- * implementation if it exists as this would cause a testing requirement to test with and without the implementations
- * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
- * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
- */
-export function arrMap<T, R>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => R, thisArg?: any): R[] {
-    let results: R[];
-
-    if (arr) {
-        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-        if (arr[strMap]) {
-            return arr[strMap](callbackfn, thisArg);
-        }
-
-        let len = arr.length;
-        let _this = thisArg || arr;
-        results = new Array(len);
-    
-        try {
-            for (let lp = 0; lp < len; lp++) {
-                if (lp in arr) {
-                    results[lp] = callbackfn.call(_this, arr[lp], arr);
-                }
-            }
-        } catch (e) {
-            // This can happen with some native browser objects, but should not happen for the type we are checking for
-        }
-    
-    }
-
-    return results;
-}
-
-/**
- * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is
- * provided as an argument in the next call to the callback function. This helper exists to avoid adding a polyfil for older browsers that do not define
- * Array.prototype.xxxx (eg. ES3 only, IE8) just in case any page checks for presence/absence of the prototype implementation. Note: For consistency
- * this will not use the Array.prototype.xxxx implementation if it exists as this would cause a testing requirement to test with and without the implementations
- * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
- * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
- */
-export function arrReduce<T, R>(arr: T[], callbackfn: (previousValue: T | R, currentValue?: T, currentIndex?: number, array?: T[]) => R, initialValue?: R): R {
-    let value;
-
-    if (arr) {
-        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-        if (arr[strReduce]) {
-            return arr[strReduce]<R>(callbackfn, initialValue);
-        }
-
-        let len = arr.length;
-        let lp = 0;
-    
-        // Specifically checking the number of passed arguments as the value could be anything
-        if (arguments.length >= 3) {
-            value = arguments[2];
-        } else {
-            while (lp < len && !(lp in arr)) {
-                lp++;
-            }
-    
-            value = arr[lp++];
-        }
-    
-        while (lp < len) {
-            if (lp in arr) {
-                value = callbackfn(value, arr[lp], lp, arr);
-            }
-            lp++;
-        }
-    }
-
-    return value;
+    return _dateToISOString.call(date);
 }
 
-/**
- * helper method to trim strings (IE8 does not implement String.prototype.trim)
- */
-export function strTrim(str: any): string {
-    if (str) {
-        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-        str = (_strTrim && str[cStrTrim]) ? str[cStrTrim]() : (str.replace ? str.replace(/^\s+|\s+$/g, STR_EMPTY) : str);
-    }
-    
-    return str;
-}
-
-let _objKeysHasDontEnumBug = !({ toString: null }).propertyIsEnumerable("toString");
-let _objKeysDontEnums = [
-    "toString",
-    "toLocaleString",
-    "valueOf",
-    "hasOwnProperty",
-    "isPrototypeOf",
-    "propertyIsEnumerable",
-    "constructor"
-];
-
-/**
- * Returns the names of the enumerable string properties and methods of an object. This helper exists to avoid adding a polyfil for older browsers
- * that do not define Object.keys eg. ES3 only, IE8 just in case any page checks for presence/absence of the prototype implementation.
- * Note: For consistency this will not use the Object.keys implementation if it exists as this would cause a testing requirement to test with and without the implementations
- * @param obj Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
- */
-export function objKeys(obj: {}): string[] {
-    var objType = typeof obj;
-
-    if (objType !== strShimFunction && (objType !== strShimObject || obj === null)) {
-        throwTypeError("objKeys called on non-object");
-    }
-
-    // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-    if (!_objKeysHasDontEnumBug && _objKeys) {
-        return _objKeys(obj);
-    }
-
-    let result: string[] = [];
-
-    for (let prop in obj) {
-        if (obj && ObjHasOwnProperty.call(obj, prop)) {
-            result.push(prop);
-        }
-    }
-
-    if (_objKeysHasDontEnumBug) {
-        let dontEnumsLength = _objKeysDontEnums.length;
-
-        for (let lp = 0; lp < dontEnumsLength; lp++) {
-            if (obj && ObjHasOwnProperty.call(obj, _objKeysDontEnums[lp])) {
-                result.push(_objKeysDontEnums[lp]);
-            }
-        }
-    }
-
-    return result;
-}
-
-/**
- * Try to define get/set object property accessors for the target object/prototype, this will provide compatibility with
- * existing API definition when run within an ES5+ container that supports accessors but still enable the code to be loaded
- * and executed in an ES3 container, providing basic IE8 compatibility.
- * @param target The object on which to define the property.
- * @param prop The name of the property to be defined or modified.
- * @param getProp The getter function to wire against the getter.
- * @param setProp The setter function to wire against the setter.
- * @returns True if it was able to create the accessors otherwise false
- */
-export function objDefineAccessors<T>(target: any, prop: string, getProp?: () => T, setProp?: (v: T) => void): boolean {
-    if (_objDefineProperty) {
-        try {
-            let descriptor: PropertyDescriptor = {
-                enumerable: true,
-                configurable: true
-            }
-
-            if (getProp) {
-                descriptor.get = getProp;
-            }
-            if (setProp) {
-                descriptor.set = setProp;
-            }
-
-            _objDefineProperty(target, prop, descriptor);
-            return true;
-        } catch (e) {
-            // IE8 Defines a defineProperty on Object but it's only supported for DOM elements so it will throw
-            // We will just ignore this here.
-        }
-    }
-
-    return false;
-}
-
-function _doNothing<T>(value: T): T {
-    return value;
-}
-
-export function deepFreeze<T>(obj: T): T {
-    if (_objFreeze) {
-        objForEachKey(obj, (name, value) => {
-            if (isArray(value) || isObject(value)) {
-                _objFreeze(value);
-            }
-        });
-    }
-
-    return objFreeze(obj);
-}
-
-export const objFreeze: <T>(value: T) => T = _objFreeze || _doNothing;
-export const objSeal: <T>(value: T) => T = _objSeal || _doNothing;
+export const deepFreeze: <T>(obj: T) => T = objDeepFreeze;
 
 /**
  * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)
@@ -706,18 +204,6 @@ export function getCfgValue<V>(theValue: V, defaultValue?: V): V {
     return !isNullOrUndefined(theValue) ? theValue : defaultValue;
 }
 
-export function isNotTruthy(value: any) {
-    return !value;
-}
-
-export function isTruthy(value: any) {
-    return !!value;
-}
-
-export function throwError(message: string): never {
-    throw new Error(message);
-}
-
 function _createProxyFunction<S>(source: S | (() => S), funcName: (keyof S)) {
     let srcFunc: () => S = null;
     let src: S = null;
@@ -767,7 +253,7 @@ export function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string,
                         target[field as string] = _createProxyFunction(source, field);
                     }
                 } else if (!chkSet || chkSet(field, false, source, target)) {
-                    if (hasOwnProperty(target, field)) {
+                    if (objHasOwnProperty(target, field)) {
                         // Remove any previous instance property
                         delete (target as any)[field];
                     }

package/src/JavaScriptSDK/InstrumentHooks.ts

@@ -2,11 +2,11 @@
 // Licensed under the MIT License.
 
 import { strShimFunction, strShimPrototype } from "@microsoft/applicationinsights-shims";
+import { getInst, objHasOwnProperty } from "@nevware21/ts-utils";
 import {
     IInstrumentCallDetails, IInstrumentHook, IInstrumentHooks, IInstrumentHooksCallbacks, InstrumentorHooksCallback
 } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
-import { getGlobalInst } from "./EnvUtils";
-import { _getObjProto, hasOwnProperty } from "./HelperFuncs";
+import { _getObjProto } from "./HelperFuncs";
 
 const aiInstrumentHooks = "_aiHooks";
 
@@ -88,7 +88,7 @@ function _createFunctionHook(aiHook:IInstrumentHooks) {
 
         let hookCtx: any[] = [];
         let cbArgs = _createArgs([funcArgs], orgArgs);
-        funcArgs.evt = getGlobalInst("event");
+        funcArgs.evt = getInst("event");
 
         function _createArgs(target:any[], theArgs:any[]): any[] {
             _arrLoop((theArgs as any), (arg) => {
@@ -134,7 +134,7 @@ function _createFunctionHook(aiHook:IInstrumentHooks) {
 function _getOwner(target:any, name:string, checkPrototype: boolean): any {
     let owner = null;
     if (target) {
-        if (hasOwnProperty(target, name)) {
+        if (objHasOwnProperty(target, name)) {
             owner = target;
         } else if (checkPrototype) {
             owner = _getOwner(_getObjProto(target), name, false);

package/src/JavaScriptSDK/InternalConstants.ts

@@ -1,9 +1,9 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-// Note: DON'T Export these const from the package as we are still targeting ES3 this will export a mutable variables that someone could change!!!
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// ###################################################################################################################################################
+// Note: DON'T Export these const from the package as we are still targeting IE/ES5 this will export a mutable variables that someone could change ###
+// ###################################################################################################################################################
 
 export const STR_EMPTY = "";
 export const STR_CHANNELS = "channels";