@vc-shell/framework 1.1.43 → 1.1.45

package/dist/vendor-microsoft-applicationinsights-properties-js-CBJTBawx.js

@@ -0,0 +1,761 @@
+import { d as dynamicProto } from './vendor-microsoft-dynamicproto-js-CFBBUu9p.js';
+import { Q as utlGetLocalStorage, U as utlCanUseLocalStorage, V as utlSetLocalStorage, n as dataSanitizeString, W as utlRemoveStorage, K as Extensions, C as CtxTagKeys, P as PageView, o as PropertiesPluginIdentifier, p as createDistributedTraceContextFromTrace, B as BreezeChannelIdentifier, k as utlSetStoragePrefix } from './vendor-microsoft-applicationinsights-common-CfmP1_Qr.js';
+import { r as isFunction, e as dumpObj, u as utcNow, o as objDefine, l as hasWindow, w as isString, P as objKeys, i as isNullOrUndefined, f as getNavigator, n as objDeepFreeze } from './vendor-nevware21-ts-utils-e8v8Jty3.js';
+import { o as onConfigChange, s as safeGetLogger, d as safeGetCookieMgr, _ as _throwInternal, a as getExceptionName, Z as newId, t as generateW3CId, g as getLocation, x as toISOString, z as setValue, $ as getSetValue, a0 as _InternalLogMessage, a1 as _logInternalMessage, i as createProcessTelemetryContext, B as BaseTelemetryPlugin } from './vendor-microsoft-applicationinsights-core-js-Cq4YSEvZ.js';
+import { _ as __extendsFn } from './vendor-microsoft-applicationinsights-shims-CX8sJgar.js';
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+
+var Application = /** @class */ (function () {
+    function Application() {
+    }
+    return Application;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+
+var Device = /** @class */ (function () {
+    /**
+     * Constructs a new instance of the Device class
+     */
+    function Device() {
+        // don't attempt to fingerprint browsers
+        this.id = "browser";
+        // Device type is a dimension in our data platform
+        // Setting it to 'Browser' allows to separate client and server dependencies/exceptions
+        this.deviceClass = "Browser";
+    }
+    return Device;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+var Version = '3.3.9';
+var Internal = /** @class */ (function () {
+    /**
+     * Constructs a new instance of the internal telemetry data class.
+     */
+    function Internal(config, unloadHookContainer) {
+        var _this = this;
+        var unloadHook = onConfigChange((config), function () {
+            var prefix = config.sdkExtension;
+            _this.sdkVersion = (prefix ? prefix + "_" : "") + "javascript:" + Version;
+        });
+        unloadHookContainer && unloadHookContainer.add(unloadHook);
+    }
+    return Internal;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+
+var Location = /** @class */ (function () {
+    function Location() {
+    }
+    return Location;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+
+// @skip-file-minify
+// ##############################################################
+// AUTO GENERATED FILE: This file is Auto Generated during build.
+// ##############################################################
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// Note: DON'T Export these const from the package as we are still targeting ES5 which can result in a mutable variables that someone could change!!!
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+var _DYN_SESSION = "session"; // Count: 4
+var _DYN_SESSION_MANAGER = "sessionManager"; // Count: 3
+var _DYN_IS_USER_COOKIE_SET = "isUserCookieSet"; // Count: 4
+var _DYN_IS_NEW_USER = "isNewUser"; // Count: 4
+var _DYN_GET_TRACE_CTX = "getTraceCtx"; // Count: 3
+var _DYN_TELEMETRY_TRACE = "telemetryTrace"; // Count: 3
+var _DYN_APPLY_SESSION_CONTEX0 = "applySessionContext"; // Count: 2
+var _DYN_APPLY_APPLICATION_CO1 = "applyApplicationContext"; // Count: 2
+var _DYN_APPLY_OPERATION_CONT2 = "applyOperationContext"; // Count: 2
+var _DYN_APPLY_OPERATING_SYST3 = "applyOperatingSystemContxt"; // Count: 2
+var _DYN_APPLY_LOCATION_CONTE4 = "applyLocationContext"; // Count: 2
+var _DYN_APPLY_INTERNAL_CONTE5 = "applyInternalContext"; // Count: 2
+var _DYN_GET_SESSION_ID = "getSessionId"; // Count: 4
+var _DYN_SESSION_COOKIE_POSTF6 = "sessionCookiePostfix"; // Count: 2
+var _DYN_AUTOMATIC_SESSION = "automaticSession"; // Count: 6
+var _DYN_ACCOUNT_ID = "accountId"; // Count: 6
+var _DYN_AUTHENTICATED_ID = "authenticatedId"; // Count: 6
+var _DYN_ACQUISITION_DATE = "acquisitionDate"; // Count: 5
+var _DYN_RENEWAL_DATE = "renewalDate"; // Count: 4
+var _DYN_COOKIE_SEPARATOR = "cookieSeparator"; // Count: 5
+var _DYN_AUTH_USER_COOKIE_NAM7 = "authUserCookieName"; // Count: 3
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+var SESSION_COOKIE_NAME = "ai_session";
+var ACQUISITION_SPAN = 86400000; // 24 hours in ms
+var RENEWAL_SPAN = 1800000; // 30 minutes in ms
+var COOKIE_UPDATE_INTERVAL = 60000; // 1 minute in ms
+var Session = /** @class */ (function () {
+    function Session() {
+    }
+    return Session;
+}());
+var _SessionManager = /** @class */ (function () {
+    function _SessionManager(config, core, unloadHookContainer) {
+        var self = this;
+        var _storageNamePrefix;
+        var _cookieUpdatedTimestamp;
+        var _logger = safeGetLogger(core);
+        var _cookieManager = safeGetCookieMgr(core);
+        var _sessionExpirationMs;
+        var _sessionRenewalMs;
+        dynamicProto(_SessionManager, self, function (_self) {
+            if (!config) {
+                config = {};
+            }
+            var unloadHook = onConfigChange(config, function (details) {
+                _sessionExpirationMs = config.sessionExpirationMs || ACQUISITION_SPAN;
+                _sessionRenewalMs = config.sessionRenewalMs || RENEWAL_SPAN;
+                // sessionCookiePostfix takes the preference if it is configured, otherwise takes namePrefix if configured.
+                var sessionCookiePostfix = config[_DYN_SESSION_COOKIE_POSTF6 /* @min:%2esessionCookiePostfix */] || config.namePrefix || "";
+                _storageNamePrefix = SESSION_COOKIE_NAME + sessionCookiePostfix;
+            });
+            unloadHookContainer && unloadHookContainer.add(unloadHook);
+            _self[_DYN_AUTOMATIC_SESSION /* @min:%2eautomaticSession */] = new Session();
+            _self.update = function () {
+                // Always using Date getTime() as there is a bug in older IE instances that causes the performance timings to have the hi-bit set eg 0x800000000 causing
+                // the number to be incorrect.
+                var nowMs = utcNow();
+                var isExpired = false;
+                var session = _self[_DYN_AUTOMATIC_SESSION /* @min:%2eautomaticSession */];
+                if (!session.id) {
+                    isExpired = !_initializeAutomaticSession(session);
+                }
+                if (!isExpired && _sessionExpirationMs > 0) {
+                    var timeSinceAcqMs = nowMs - session[_DYN_ACQUISITION_DATE /* @min:%2eacquisitionDate */];
+                    var timeSinceRenewalMs = nowMs - session[_DYN_RENEWAL_DATE /* @min:%2erenewalDate */];
+                    isExpired = timeSinceAcqMs < 0 || timeSinceRenewalMs < 0; // expired if the acquisition or last renewal are in the future
+                    isExpired = isExpired || timeSinceAcqMs > _sessionExpirationMs; // expired if the time since acquisition is more than session Expiration
+                    isExpired = isExpired || timeSinceRenewalMs > _sessionRenewalMs; // expired if the time since last renewal is more than renewal period
+                }
+                // renew if acquisitionSpan or renewalSpan has elapsed
+                if (isExpired) {
+                    // update automaticSession so session state has correct id
+                    _renew(nowMs);
+                }
+                else {
+                    // do not update the cookie more often than cookieUpdateInterval
+                    if (!_cookieUpdatedTimestamp || nowMs - _cookieUpdatedTimestamp > COOKIE_UPDATE_INTERVAL) {
+                        _setCookie(session, nowMs);
+                    }
+                }
+            };
+            /**
+             *  Record the current state of the automatic session and store it in our cookie string format
+             *  into the browser's local storage. This is used to restore the session data when the cookie
+             *  expires.
+             */
+            _self.backup = function () {
+                var session = _self[_DYN_AUTOMATIC_SESSION /* @min:%2eautomaticSession */];
+                _setStorage(session.id, session[_DYN_ACQUISITION_DATE /* @min:%2eacquisitionDate */], session[_DYN_RENEWAL_DATE /* @min:%2erenewalDate */]);
+            };
+            /**
+             * Use config.namePrefix + ai_session cookie data or local storage data (when the cookie is unavailable) to
+             * initialize the automatic session.
+             * @returns true if values set otherwise false
+             */
+            function _initializeAutomaticSession(session, now) {
+                var isValid = false;
+                var cookieValue = _cookieManager.get(_storageNamePrefix);
+                if (cookieValue && isFunction(cookieValue.split)) {
+                    isValid = _initializeAutomaticSessionWithData(session, cookieValue);
+                }
+                else {
+                    // There's no cookie, but we might have session data in local storage
+                    // This can happen if the session expired or the user actively deleted the cookie
+                    // We only want to recover data if the cookie is missing from expiry. We should respect the user's wishes if the cookie was deleted actively.
+                    // The User class handles this for us and deletes our local storage object if the persistent user cookie was removed.
+                    var storageValue = utlGetLocalStorage(_logger, _storageNamePrefix);
+                    if (storageValue) {
+                        isValid = _initializeAutomaticSessionWithData(session, storageValue);
+                    }
+                }
+                return isValid || !!session.id;
+            }
+            /**
+             * Extract id, acquisitionDate, and renewalDate from an ai_session payload string and
+             * use this data to initialize automaticSession.
+             *
+             * @param sessionData - The string stored in an ai_session cookie or local storage backup
+             * @returns true if values set otherwise false
+             */
+            function _initializeAutomaticSessionWithData(session, sessionData) {
+                var isValid = false;
+                var sessionReset = ", session will be reset";
+                var tokens = sessionData.split("|");
+                if (tokens.length >= 2) {
+                    try {
+                        var acqMs = +tokens[1] || 0;
+                        var renewalMs = +tokens[2] || 0;
+                        if (isNaN(acqMs) || acqMs <= 0) {
+                            _throwInternal(_logger, 2 /* eLoggingSeverity.WARNING */, 27 /* _eInternalMessageId.SessionRenewalDateIsZero */, "AI session acquisition date is 0" + sessionReset);
+                        }
+                        else if (isNaN(renewalMs) || renewalMs <= 0) {
+                            _throwInternal(_logger, 2 /* eLoggingSeverity.WARNING */, 27 /* _eInternalMessageId.SessionRenewalDateIsZero */, "AI session renewal date is 0" + sessionReset);
+                        }
+                        else if (tokens[0]) {
+                            // Everything looks valid so set the values
+                            session.id = tokens[0];
+                            session[_DYN_ACQUISITION_DATE /* @min:%2eacquisitionDate */] = acqMs;
+                            session[_DYN_RENEWAL_DATE /* @min:%2erenewalDate */] = renewalMs;
+                            isValid = true;
+                        }
+                    }
+                    catch (e) {
+                        _throwInternal(_logger, 1 /* eLoggingSeverity.CRITICAL */, 9 /* _eInternalMessageId.ErrorParsingAISessionCookie */, "Error parsing ai_session value [" + (sessionData || "") + "]" + sessionReset + " - " + getExceptionName(e), { exception: dumpObj(e) });
+                    }
+                }
+                return isValid;
+            }
+            function _renew(nowMs) {
+                var getNewId = config.getNewId || newId;
+                _self[_DYN_AUTOMATIC_SESSION /* @min:%2eautomaticSession */].id = getNewId(config.idLength || 22);
+                _self[_DYN_AUTOMATIC_SESSION /* @min:%2eautomaticSession */][_DYN_ACQUISITION_DATE /* @min:%2eacquisitionDate */] = nowMs;
+                _setCookie(_self[_DYN_AUTOMATIC_SESSION /* @min:%2eautomaticSession */], nowMs);
+                // If this browser does not support local storage, fire an internal log to keep track of it at this point
+                if (!utlCanUseLocalStorage()) {
+                    _throwInternal(_logger, 2 /* eLoggingSeverity.WARNING */, 0 /* _eInternalMessageId.BrowserDoesNotSupportLocalStorage */, "Browser does not support local storage. Session durations will be inaccurate.");
+                }
+            }
+            function _setCookie(session, nowMs) {
+                var acq = session[_DYN_ACQUISITION_DATE /* @min:%2eacquisitionDate */];
+                session[_DYN_RENEWAL_DATE /* @min:%2erenewalDate */] = nowMs;
+                var renewalPeriodMs = _sessionRenewalMs;
+                // Set cookie to expire after the session expiry time passes or the session renewal deadline, whichever is sooner
+                // Expiring the cookie will cause the session to expire even if the user isn't on the page
+                var acqTimeLeftMs = (acq + _sessionExpirationMs) - nowMs;
+                var cookie = [session.id, acq, nowMs];
+                var maxAgeSec = 0;
+                if (acqTimeLeftMs < renewalPeriodMs) {
+                    maxAgeSec = acqTimeLeftMs / 1000;
+                }
+                else {
+                    maxAgeSec = renewalPeriodMs / 1000;
+                }
+                var cookieDomain = config.cookieDomain || null;
+                // if sessionExpirationMs is set to 0, it means the expiry is set to 0 for this session cookie
+                // A cookie with 0 expiry in the session cookie will never expire for that browser session.  If the browser is closed the cookie expires.
+                // Depending on the browser, another instance does not inherit this cookie, however, another tab will
+                _cookieManager.set(_storageNamePrefix, cookie.join("|"), _sessionExpirationMs > 0 ? maxAgeSec : null, cookieDomain);
+                _cookieUpdatedTimestamp = nowMs;
+            }
+            function _setStorage(guid, acq, renewal) {
+                // Keep data in local storage to retain the last session id, allowing us to cleanly end the session when it expires
+                // Browsers that don't support local storage won't be able to end sessions cleanly from the client
+                // The server will notice this and end the sessions itself, with loss of accurate session duration
+                utlSetLocalStorage(_logger, _storageNamePrefix, [guid, acq, renewal].join("|"));
+            }
+        });
+    }
+// Removed Stub for _SessionManager.prototype.update.
+// Removed Stub for _SessionManager.prototype.backup.
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    _SessionManager.__ieDyn=1;
+
+    return _SessionManager;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+var TelemetryTrace = /** @class */ (function () {
+    function TelemetryTrace(id, parentId, name, logger) {
+        var _self = this;
+        _self.traceID = id || generateW3CId();
+        _self.parentID = parentId;
+        var location = getLocation();
+        if (!name && location && location.pathname) {
+            name = location.pathname;
+        }
+        _self.name = dataSanitizeString(logger, name);
+    }
+    return TelemetryTrace;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+function _validateUserInput(id) {
+    // Validate:
+    // 1. Id is a non-empty string.
+    // 2. It does not contain special characters for cookies.
+    if (typeof id !== "string" ||
+        !id ||
+        id.match(/,|;|=| |\|/)) {
+        return false;
+    }
+    return true;
+}
+var User = /** @class */ (function () {
+    function User(config, core, unloadHookContainer) {
+        /**
+         * A flag indicating whether this represents a new user
+         */
+        this.isNewUser = false;
+        /**
+         * A flag indicating whether the user cookie has been set
+         */
+        this.isUserCookieSet = false;
+        var _logger = safeGetLogger(core);
+        var _cookieManager = safeGetCookieMgr(core);
+        var _storageNamePrefix;
+        dynamicProto(User, this, function (_self) {
+            // Define _self.config
+            objDefine(_self, "config", {
+                g: function () { return config; }
+            });
+            var unloadHook = onConfigChange(config, function () {
+                var userCookiePostfix = config.userCookiePostfix || "";
+                _storageNamePrefix = User.userCookieName + userCookiePostfix;
+                // get userId or create new one if none exists
+                var cookie = _cookieManager.get(_storageNamePrefix);
+                if (cookie) {
+                    _self[_DYN_IS_NEW_USER /* @min:%2eisNewUser */] = false;
+                    var params = cookie.split(User[_DYN_COOKIE_SEPARATOR /* @min:%2ecookieSeparator */]);
+                    if (params.length > 0) {
+                        _self.id = params[0];
+                        // we already have a cookie
+                        _self[_DYN_IS_USER_COOKIE_SET /* @min:%2eisUserCookieSet */] = !!_self.id;
+                    }
+                }
+                if (!_self.id) {
+                    _self.id = _generateNewId();
+                    var newCookie = _generateNewCookie(_self.id);
+                    _setUserCookie(newCookie.join(User[_DYN_COOKIE_SEPARATOR /* @min:%2ecookieSeparator */]));
+                    // If we have an config.namePrefix() + ai_session in local storage this means the user actively removed our cookies.
+                    // We should respect their wishes and clear ourselves from local storage
+                    var name_1 = (config.namePrefix || "") + "ai_session";
+                    utlRemoveStorage(_logger, name_1);
+                }
+                // We still take the account id from the ctor param for backward compatibility.
+                // But if the the customer set the accountId through the newer setAuthenticatedUserContext API, we will override it.
+                _self[_DYN_ACCOUNT_ID /* @min:%2eaccountId */] = config[_DYN_ACCOUNT_ID /* @min:%2eaccountId */] || undefined;
+                // Get the auth user id and account id from the cookie if exists
+                // Cookie is in the pattern: <authenticatedId>|<accountId>
+                var authCookie = _cookieManager.get(User[_DYN_AUTH_USER_COOKIE_NAM7 /* @min:%2eauthUserCookieName */]);
+                if (authCookie) {
+                    authCookie = decodeURI(authCookie);
+                    var authCookieString = authCookie.split(User[_DYN_COOKIE_SEPARATOR /* @min:%2ecookieSeparator */]);
+                    if (authCookieString[0]) {
+                        _self[_DYN_AUTHENTICATED_ID /* @min:%2eauthenticatedId */] = authCookieString[0];
+                    }
+                    if (authCookieString.length > 1 && authCookieString[1]) {
+                        _self[_DYN_ACCOUNT_ID /* @min:%2eaccountId */] = authCookieString[1];
+                    }
+                }
+            });
+            unloadHookContainer && unloadHookContainer.add(unloadHook);
+            function _generateNewId() {
+                var theConfig = (config || {});
+                var getNewId = theConfig.getNewId || newId;
+                var id = getNewId(theConfig.idLength ? config.idLength : 22);
+                return id;
+            }
+            function _generateNewCookie(userId) {
+                var acqStr = toISOString(new Date());
+                _self.accountAcquisitionDate = acqStr;
+                _self[_DYN_IS_NEW_USER /* @min:%2eisNewUser */] = true;
+                var newCookie = [userId, acqStr];
+                return newCookie;
+            }
+            function _setUserCookie(cookie) {
+                // without expiration, cookies expire at the end of the session
+                // set it to 365 days from now
+                // 365 * 24 * 60 * 60 = 31536000
+                var oneYear = 31536000;
+                _self[_DYN_IS_USER_COOKIE_SET /* @min:%2eisUserCookieSet */] = _cookieManager.set(_storageNamePrefix, cookie, oneYear);
+            }
+            _self.setAuthenticatedUserContext = function (authenticatedUserId, accountId, storeInCookie) {
+                if (storeInCookie === void 0) { storeInCookie = false; }
+                // Validate inputs to ensure no cookie control characters.
+                var isInvalidInput = !_validateUserInput(authenticatedUserId) || (accountId && !_validateUserInput(accountId));
+                if (isInvalidInput) {
+                    _throwInternal(_logger, 2 /* eLoggingSeverity.WARNING */, 60 /* _eInternalMessageId.SetAuthContextFailedAccountName */, "Setting auth user context failed. " +
+                        "User auth/account id should be of type string, and not contain commas, semi-colons, equal signs, spaces, or vertical-bars.", true);
+                    return;
+                }
+                // Create cookie string.
+                _self[_DYN_AUTHENTICATED_ID /* @min:%2eauthenticatedId */] = authenticatedUserId;
+                var authCookie = _self[_DYN_AUTHENTICATED_ID /* @min:%2eauthenticatedId */];
+                if (accountId) {
+                    _self[_DYN_ACCOUNT_ID /* @min:%2eaccountId */] = accountId;
+                    authCookie = [_self[_DYN_AUTHENTICATED_ID /* @min:%2eauthenticatedId */], _self.accountId].join(User[_DYN_COOKIE_SEPARATOR /* @min:%2ecookieSeparator */]);
+                }
+                if (storeInCookie) {
+                    // Set the cookie. No expiration date because this is a session cookie (expires when browser closed).
+                    // Encoding the cookie to handle unexpected unicode characters.
+                    _cookieManager.set(User[_DYN_AUTH_USER_COOKIE_NAM7 /* @min:%2eauthUserCookieName */], encodeURI(authCookie));
+                }
+            };
+            /**
+             * Clears the authenticated user id and the account id from the user context.
+             * @returns {}
+             */
+            _self.clearAuthenticatedUserContext = function () {
+                _self[_DYN_AUTHENTICATED_ID /* @min:%2eauthenticatedId */] = null;
+                _self[_DYN_ACCOUNT_ID /* @min:%2eaccountId */] = null;
+                _cookieManager.del(User[_DYN_AUTH_USER_COOKIE_NAM7 /* @min:%2eauthUserCookieName */]);
+            };
+            _self.update = function (userId) {
+                // Optimizations to avoid setting and processing the cookie when not needed
+                if (_self.id !== userId || !_self[_DYN_IS_USER_COOKIE_SET /* @min:%2eisUserCookieSet */]) {
+                    var user_id = userId ? userId : _generateNewId();
+                    var user_cookie = _generateNewCookie(user_id);
+                    _setUserCookie(user_cookie.join(User[_DYN_COOKIE_SEPARATOR /* @min:%2ecookieSeparator */]));
+                }
+            };
+        });
+    }
+// Removed Stub for User.prototype.setAuthenticatedUserContext.
+// Removed Stub for User.prototype.clearAuthenticatedUserContext.
+// Removed Stub for User.prototype.update.
+    User.cookieSeparator = "|";
+    User.userCookieName = "ai_user";
+    User.authUserCookieName = "ai_authUser";
+    return User;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+/**
+* TelemetryContext.ts
+* @copyright Microsoft 2018
+*/
+var strExt = "ext";
+var strTags = "tags";
+function _removeEmpty(target, name) {
+    if (target && target[name] && objKeys(target[name]).length === 0) {
+        delete target[name];
+    }
+}
+function _nullResult() {
+    return null;
+}
+var TelemetryContext = /** @class */ (function () {
+    function TelemetryContext(core, defaultConfig, previousTraceCtx, unloadHookContainer) {
+        var _this = this;
+        var logger = core.logger;
+        dynamicProto(TelemetryContext, this, function (_self) {
+            _self.appId = _nullResult;
+            _self[_DYN_GET_SESSION_ID /* @min:%2egetSessionId */] = _nullResult;
+            _self.application = new Application();
+            _self.internal = new Internal(defaultConfig, unloadHookContainer);
+            if (hasWindow()) {
+                _self[_DYN_SESSION_MANAGER /* @min:%2esessionManager */] = new _SessionManager(defaultConfig, core, unloadHookContainer);
+                _self.device = new Device();
+                _self.location = new Location();
+                _self.user = new User(defaultConfig, core, unloadHookContainer);
+                var traceId = void 0;
+                var parentId = void 0;
+                var name_1;
+                if (previousTraceCtx) {
+                    traceId = previousTraceCtx.getTraceId();
+                    parentId = previousTraceCtx.getSpanId();
+                    name_1 = previousTraceCtx.getName();
+                }
+                _self[_DYN_TELEMETRY_TRACE /* @min:%2etelemetryTrace */] = new TelemetryTrace(traceId, parentId, name_1, logger);
+                _self[_DYN_SESSION /* @min:%2esession */] = new Session();
+            }
+            _self[_DYN_GET_SESSION_ID /* @min:%2egetSessionId */] = function () {
+                var session = _self[_DYN_SESSION /* @min:%2esession */];
+                var sesId = null;
+                // If customer set session info, apply their context; otherwise apply context automatically generated
+                if (session && isString(session.id)) {
+                    sesId = session.id;
+                }
+                else {
+                    // Gets the automatic session if it exists or an empty object
+                    var autoSession = (_self[_DYN_SESSION_MANAGER /* @min:%2esessionManager */] || {})[_DYN_AUTOMATIC_SESSION /* @min:%2eautomaticSession */];
+                    sesId = autoSession && isString(autoSession.id) ? autoSession.id : null;
+                }
+                return sesId;
+            };
+            _self[_DYN_APPLY_SESSION_CONTEX0 /* @min:%2eapplySessionContext */] = function (evt, itemCtx) {
+                setValue(getSetValue(evt.ext, Extensions.AppExt), "sesId", _self[_DYN_GET_SESSION_ID /* @min:%2egetSessionId */](), isString);
+            };
+            _self[_DYN_APPLY_OPERATING_SYST3 /* @min:%2eapplyOperatingSystemContxt */] = function (evt, itemCtx) {
+                setValue(evt.ext, Extensions.OSExt, _self.os);
+            };
+            _self[_DYN_APPLY_APPLICATION_CO1 /* @min:%2eapplyApplicationContext */] = function (evt, itemCtx) {
+                var application = _self.application;
+                if (application) {
+                    // evt.ext.app
+                    var tags = getSetValue(evt, strTags);
+                    setValue(tags, CtxTagKeys.applicationVersion, application.ver, isString);
+                    setValue(tags, CtxTagKeys.applicationBuild, application.build, isString);
+                }
+            };
+            _self.applyDeviceContext = function (evt, itemCtx) {
+                var device = _self.device;
+                if (device) {
+                    // evt.ext.device
+                    var extDevice = getSetValue(getSetValue(evt, strExt), Extensions.DeviceExt);
+                    setValue(extDevice, "localId", device.id, isString);
+                    setValue(extDevice, "ip", device.ip, isString);
+                    setValue(extDevice, "model", device.model, isString);
+                    setValue(extDevice, "deviceClass", device.deviceClass, isString);
+                }
+            };
+            _self[_DYN_APPLY_INTERNAL_CONTE5 /* @min:%2eapplyInternalContext */] = function (evt, itemCtx) {
+                var internal = _self.internal;
+                if (internal) {
+                    var tags = getSetValue(evt, strTags);
+                    setValue(tags, CtxTagKeys.internalAgentVersion, internal.agentVersion, isString); // not mapped in CS 4.0
+                    setValue(tags, CtxTagKeys.internalSdkVersion, dataSanitizeString(logger, internal.sdkVersion, 64), isString);
+                    if (evt.baseType === _InternalLogMessage.dataType || evt.baseType === PageView.dataType) {
+                        setValue(tags, CtxTagKeys.internalSnippet, internal.snippetVer, isString);
+                        setValue(tags, CtxTagKeys.internalSdkSrc, internal.sdkSrc, isString);
+                    }
+                }
+            };
+            _self[_DYN_APPLY_LOCATION_CONTE4 /* @min:%2eapplyLocationContext */] = function (evt, itemCtx) {
+                var location = _this.location;
+                if (location) {
+                    setValue(getSetValue(evt, strTags, []), CtxTagKeys.locationIp, location.ip, isString);
+                }
+            };
+            _self[_DYN_APPLY_OPERATION_CONT2 /* @min:%2eapplyOperationContext */] = function (evt, itemCtx) {
+                var telemetryTrace = _self[_DYN_TELEMETRY_TRACE /* @min:%2etelemetryTrace */];
+                if (telemetryTrace) {
+                    var extTrace = getSetValue(getSetValue(evt, strExt), Extensions.TraceExt, { traceID: undefined, parentID: undefined });
+                    setValue(extTrace, "traceID", telemetryTrace.traceID, isString, isNullOrUndefined);
+                    setValue(extTrace, "name", telemetryTrace.name, isString, isNullOrUndefined);
+                    setValue(extTrace, "parentID", telemetryTrace.parentID, isString, isNullOrUndefined);
+                }
+            };
+            _self.applyWebContext = function (evt, itemCtx) {
+                var web = _this.web;
+                if (web) {
+                    setValue(getSetValue(evt, strExt), Extensions.WebExt, web);
+                }
+            };
+            _self.applyUserContext = function (evt, itemCtx) {
+                var user = _self.user;
+                if (user) {
+                    var tags = getSetValue(evt, strTags, []);
+                    // stays in tags
+                    setValue(tags, CtxTagKeys.userAccountId, user[_DYN_ACCOUNT_ID /* @min:%2eaccountId */], isString);
+                    // CS 4.0
+                    var extUser = getSetValue(getSetValue(evt, strExt), Extensions.UserExt);
+                    setValue(extUser, "id", user.id, isString);
+                    setValue(extUser, "authId", user[_DYN_AUTHENTICATED_ID /* @min:%2eauthenticatedId */], isString);
+                }
+            };
+            _self.cleanUp = function (evt, itemCtx) {
+                var ext = evt.ext;
+                if (ext) {
+                    _removeEmpty(ext, Extensions.DeviceExt);
+                    _removeEmpty(ext, Extensions.UserExt);
+                    _removeEmpty(ext, Extensions.WebExt);
+                    _removeEmpty(ext, Extensions.OSExt);
+                    _removeEmpty(ext, Extensions.AppExt);
+                    _removeEmpty(ext, Extensions.TraceExt);
+                }
+            };
+        });
+    }
+// Removed Stub for TelemetryContext.prototype.applySessionContext.
+// Removed Stub for TelemetryContext.prototype.applyOperatingSystemContxt.
+// Removed Stub for TelemetryContext.prototype.applyApplicationContext.
+// Removed Stub for TelemetryContext.prototype.applyDeviceContext.
+// Removed Stub for TelemetryContext.prototype.applyInternalContext.
+// Removed Stub for TelemetryContext.prototype.applyLocationContext.
+// Removed Stub for TelemetryContext.prototype.applyOperationContext.
+// Removed Stub for TelemetryContext.prototype.applyWebContext.
+// Removed Stub for TelemetryContext.prototype.applyUserContext.
+// Removed Stub for TelemetryContext.prototype.cleanUp.
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    TelemetryContext.__ieDyn=1;
+
+    return TelemetryContext;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Properties Plugin, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+/**
+* PropertiesPlugin.ts
+* @copyright Microsoft 2018
+*/
+var _a;
+var undefString;
+var nullValue = null;
+var _defaultConfig = objDeepFreeze((_a = {
+        accountId: nullValue,
+        sessionRenewalMs: 30 * 60 * 1000,
+        samplingPercentage: 100,
+        sessionExpirationMs: 24 * 60 * 60 * 1000,
+        cookieDomain: nullValue,
+        sdkExtension: nullValue,
+        isBrowserLinkTrackingEnabled: false,
+        appId: nullValue
+    },
+    _a[_DYN_GET_SESSION_ID /* @min:getSessionId */] = nullValue,
+    _a.namePrefix = undefString,
+    _a[_DYN_SESSION_COOKIE_POSTF6 /* @min:sessionCookiePostfix */] = undefString,
+    _a.userCookiePostfix = undefString,
+    _a.idLength = 22,
+    _a.getNewId = nullValue,
+    _a));
+var PropertiesPlugin = /** @class */ (function (_super) {
+    __extendsFn(PropertiesPlugin, _super);
+    function PropertiesPlugin() {
+        var _this = _super.call(this) || this;
+        _this.priority = 110;
+        _this.identifier = PropertiesPluginIdentifier;
+        var _extensionConfig;
+        var _distributedTraceCtx;
+        var _previousTraceCtx;
+        var _context;
+        var _disableUserInitMessage;
+        dynamicProto(PropertiesPlugin, _this, function (_self, _base) {
+            _initDefaults();
+            objDefine(_self, "context", {
+                g: function () {
+                    return _context;
+                }
+            });
+            _self.initialize = function (config, core, extensions, pluginChain) {
+                _base.initialize(config, core, extensions, pluginChain);
+                _populateDefaults(config);
+            };
+            /**
+             * Add Part A fields to the event
+             * @param event - The event that needs to be processed
+             */
+            _self.processTelemetry = function (event, itemCtx) {
+                if (!isNullOrUndefined(event)) {
+                    itemCtx = _self._getTelCtx(itemCtx);
+                    // If the envelope is PageView, reset the internal message count so that we can send internal telemetry for the new page.
+                    if (event.name === PageView.envelopeType) {
+                        itemCtx.diagLog().resetInternalMessageCount();
+                    }
+                    var theContext = (_context || {});
+                    if (theContext[_DYN_SESSION /* @min:%2esession */]) {
+                        // If customer did not provide custom session id update the session manager
+                        if (typeof _context[_DYN_SESSION /* @min:%2esession */].id !== "string" && theContext[_DYN_SESSION_MANAGER /* @min:%2esessionManager */]) {
+                            theContext[_DYN_SESSION_MANAGER /* @min:%2esessionManager */].update();
+                        }
+                    }
+                    var userCtx = theContext.user;
+                    if (userCtx && !userCtx[_DYN_IS_USER_COOKIE_SET /* @min:%2eisUserCookieSet */]) {
+                        userCtx.update(theContext.user.id);
+                    }
+                    _processTelemetryInternal(event, itemCtx);
+                    if (userCtx && userCtx[_DYN_IS_NEW_USER /* @min:%2eisNewUser */]) {
+                        userCtx[_DYN_IS_NEW_USER /* @min:%2eisNewUser */] = false;
+                        if (!_disableUserInitMessage) {
+                            var message = new _InternalLogMessage(72 /* _eInternalMessageId.SendBrowserInfoOnUserInit */, ((getNavigator() || {}).userAgent || ""));
+                            _logInternalMessage(itemCtx.diagLog(), 1 /* eLoggingSeverity.CRITICAL */, message);
+                        }
+                    }
+                    _self.processNext(event, itemCtx);
+                }
+            };
+            _self._doTeardown = function (unloadCtx, unloadState) {
+                var core = (unloadCtx || {}).core();
+                if (core && core[_DYN_GET_TRACE_CTX /* @min:%2egetTraceCtx */]) {
+                    var traceCtx = core[_DYN_GET_TRACE_CTX /* @min:%2egetTraceCtx */](false);
+                    if (traceCtx === _distributedTraceCtx) {
+                        core.setTraceCtx(_previousTraceCtx);
+                    }
+                }
+                _initDefaults();
+            };
+            function _initDefaults() {
+                _extensionConfig = null;
+                _distributedTraceCtx = null;
+                _previousTraceCtx = null;
+                _context = null;
+                _disableUserInitMessage = true;
+            }
+            function _populateDefaults(config) {
+                var identifier = _self.identifier;
+                var core = _self.core;
+                // This function will be re-called whenever any referenced configuration is changed
+                _self._addHook(onConfigChange(config, function () {
+                    var ctx = createProcessTelemetryContext(null, config, core);
+                    if (config.storagePrefix) {
+                        utlSetStoragePrefix(config.storagePrefix);
+                    }
+                    _disableUserInitMessage = config.disableUserInitMessage === false ? false : true;
+                    _extensionConfig = ctx.getExtCfg(identifier, _defaultConfig);
+                    // Test hook to allow accessing the internal values -- explicitly not defined as an available property on the class
+                    _self["_extConfig"] = _extensionConfig;
+                }));
+                // This is outside of the onConfigChange as we don't want to update (replace) these values whenever a referenced config item changes
+                _previousTraceCtx = core[_DYN_GET_TRACE_CTX /* @min:%2egetTraceCtx */](false);
+                _context = new TelemetryContext(core, _extensionConfig, _previousTraceCtx, _self._unloadHooks);
+                _distributedTraceCtx = createDistributedTraceContextFromTrace(_self.context[_DYN_TELEMETRY_TRACE /* @min:%2etelemetryTrace */], _previousTraceCtx);
+                core.setTraceCtx(_distributedTraceCtx);
+                _self.context.appId = function () {
+                    var breezeChannel = core.getPlugin(BreezeChannelIdentifier);
+                    return breezeChannel ? breezeChannel.plugin["_appId"] : null;
+                };
+            }
+            function _processTelemetryInternal(evt, itemCtx) {
+                // Set Part A fields
+                getSetValue(evt, "tags", []);
+                getSetValue(evt, "ext", {});
+                var ctx = _self.context;
+                ctx[_DYN_APPLY_SESSION_CONTEX0 /* @min:%2eapplySessionContext */](evt, itemCtx);
+                ctx[_DYN_APPLY_APPLICATION_CO1 /* @min:%2eapplyApplicationContext */](evt, itemCtx);
+                ctx.applyDeviceContext(evt, itemCtx);
+                ctx[_DYN_APPLY_OPERATION_CONT2 /* @min:%2eapplyOperationContext */](evt, itemCtx);
+                ctx.applyUserContext(evt, itemCtx);
+                ctx[_DYN_APPLY_OPERATING_SYST3 /* @min:%2eapplyOperatingSystemContxt */](evt, itemCtx);
+                ctx.applyWebContext(evt, itemCtx);
+                ctx[_DYN_APPLY_LOCATION_CONTE4 /* @min:%2eapplyLocationContext */](evt, itemCtx); // legacy tags
+                ctx[_DYN_APPLY_INTERNAL_CONTE5 /* @min:%2eapplyInternalContext */](evt, itemCtx); // legacy tags
+                ctx.cleanUp(evt, itemCtx);
+            }
+        });
+        return _this;
+    }
+// Removed Stub for PropertiesPlugin.prototype.initialize.
+// Removed Stub for PropertiesPlugin.prototype.processTelemetry.
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    PropertiesPlugin.__ieDyn=1;
+
+    return PropertiesPlugin;
+}(BaseTelemetryPlugin));
+
+export { PropertiesPlugin as P };